Podcast appearances and mentions of Guido van Rossum

Katia, Guillaume, Emmanuel et Antonio discutent Kotlin, Micronaut, Spring Boot, Quarkus, Langchain4j, LLMs en Java, builds reproductible et la question AMA du jour, comment fait-on carrière de dev à 40 ans ? Enregistré le 14 juin 2024 Téléchargement de l'épisode LesCastCodeurs-Episode-313.mp3 News Langages Android avec Kotlin Multiplatform our Flutter avec Dart ? https://developers.googleblog.com/en/making-development-across-platforms-easier-for-developers/ Des licenciements ont continué chez Google et l'équipe Flutter/Dart comme plein d'autres ont été touchées, mais sur les réseaux sociaux les gens ont pensé que Google désinvestissait dans Flutter et Dart. Par ailleurs, côté Android, ils poussent plutôt du côté de Kotlin et KMP, mais naturellement aussi les gens se sont demandé si Google avait pris parti pour pousser plus Kotlin/KMP plutôt que Flutter/Dart. Pour essayer de mieux faire comprendre aux développeurs l'intérêt des deux plateformes, et leurs avantages et inconvénients, les directeurs des deux plateformes ont rédigé un article commun. Si l'on souhaite une expérience plus proche du hardware et des dernières nouveautés d'Android, et d'avoir aussi une UI/UX vraiment native Android, mieux vaut aller du côté de Kotlin/KMP. Si l'on souhaite par contre une expérience multiplateforme Web, mobile, desktop avec une UX commune cross-plateforme, avec également le partage de business logic à partir d'une même base de code, Flutter et Dart sont plus adaptés. Recap de KotlinConf https://x.com/gz_k/status/1793887581433971083?s=46&t=C18cckWlfukmsB_Fx0FfxQ RPC multiplatform la pres Grow with the flow montrant la reecriture en kotlin plus simple que des solutions complexes ailleurs power-assert pour ecrire des tests Kotlin 2.0 et les evolutions majeures Kotlin multiplatforme mainteant stable Kotlin Compose Multiplatform continue a amturer Retour d'experience de la migration d'android jetpack vers Kotlin Multiplatform use cases de coroutines et scope Librairies Quarkus veut aller dans une fondation https://quarkus.io/blog/quarkus-in-a-foundation/ ameliorer l'adoption (encore plus), ameliorer la transparence, et la collaboration, encourager la participatiopn multi vendeur Premiere etape : une gouvernance plus overte Deuxieme etape: bouger dans uen foundation Echange avec la communaute sur la proposition et les fondations cibles Des criteres pour al foudnation (notamment la rapidite de delivery Quarkus 3.11 https://quarkus.io/blog/quarkus-3-11-0-released/ Websocket.next en cours Dev services pour observabilite (grafana, jaegel, open telemetry extension infinispan cache #38448 - Observability extensions - Dev Services, Dev Resources, LGTM #39836 - Infinispan Cache Extension #40309 - WebSockets Next: client endpoints #40534 - WebSockets Next: initial version of security integration #40273 - Allow quarkus:run to launch Dev Services #40539 - Support for OIDC session expired page #40600 - Introduce OidcRedirectFilter LangChain4j 0.31 est sorti https://github.com/langchain4j/langchain4j/releases/tag/0.31.0 Recherche Web pour le RAG avec Google et Tavily RAG avec les bases de données SQL (expérimental) Récupération des resources remontées par le RAG lorsque AiServices retourne un Result Observabilité LLM pour OpenAI pour être notifié des requêtes, réponses et erreurs Intégration de Cohere (embedding), Jina (embedding et re-ranking scoring), Azuere CosmosDB comme embedding store Mise à jour de Gemini avec le parallel function calling et les instructions système Spring Boot 3.3.0 est sorti https://spring.io/blog/2024/05/23/spring-boot-3-3-0-available-now support Class Data Sharing Micrometer sipport de spantag etc Amelioration Spring Security comme JwtAuthenticationCovnerter support docker compose pour les images container bitnami Virtual thread pour les websockets Support sBOM via an actuator SNI for embedded web servers une nouvelle doc via antora Micronaut 4.5 est sortie https://github.com/micronaut-projects/micronaut-platform/releases/tag/v4.5.0 Le serveur basé sur Netty inclus la détection d'opération bloquante et les modules l'utilisant indiqueront à l'utilisateur quand certaines opérations peuvent être redirigée plutôt sur un virtual thread ou dans le thread pool IO Micronaut Data inclus le support de la multitenance avec partitionnement par discriminateur pour JDBC et R2DBC Micronaut Data rajoute le pagination par curseur pour JDBC et R2DBC (important aussi pour Jakarta Data) Support des annotations Jakarta Servlet pour configurer par exemple les servelet filters Support virtual thread et HTTP/2 Un nouveau module JSON Schema pour générer des JSON Schemas pour les records Java Un nouveau module Source Gen pour faire de la génération de source pour Java et Kotlin cross-language Un nouveau module Guice pour importer des modules Guice existants Web Angular 18 est sorti https://blog.angular.dev/angular-v18-is-now-available-e79d5ac0affe Support expérimental pour la détection de changement sans zone Angular.dev est désormais le nouveau site pour les développeurs Angular Material 3, les “deferrable views”, le “built-in control flow” sont maintenant stables et intègrent une série d'améliorations Améliorations du rendu côté serveur telles que le support de l'hydratation i18n, un meilleur débogage, le support de l'hydratation dans Angular Material, et la event replay qui utilise la même bibliothèque que Google Search. Data et Intelligence Artificielle Une version pure Java du LLM Llama3 de Meta https://github.com/mukel/llama3.java/tree/main utilise la future API Vector de Java JLama, un moteur d‘exécution de LLM en Java avec l'api vector https://www.infoq.com/news/2024/05/jlama-llm-inference-java/ basé sur llama.c qui est un moteur d'inference de LLM (l'execution des requetes) jlama implementé avec vector APIs et PamanaTensorOperations plusisures alternatives (native binding, iml0ementation pure en java, scala, kotlin) Target Speech Hearing https://www.infoq.com/news/2024/05/target-speech-hearing/ Nouveau algo Deep Learning de l'Université de Washington permet d'écouter une seule personne de ton choix et effacer tout le bruit autour le système nécessite que la personne portant les écouteurs appuie sur un bouton tout en regardant quelqu'un parler ou simplement en le fixant pendant trois à cinq secondes Permet à un modèle d'apprendre les schémas vocaux du locuteur et de s'y attacher pour pouvoir les restituer à l'auditeur, même s'il se déplace et cesse de regarder cette personne. Selon les chercheurs, cela constitue une avancée significative par rapport aux écouteurs à réduction de bruit existants, qui peuvent annuler efficacement tous les sons, mais ne peuvent pas sélectionner les locuteurs en fonction de leurs caractéristiques vocales. Actuellement, le système ne peut enregistrer qu'un seul locuteur à la fois. Une autre limitation est que l'enregistrement ne réussira que si aucune autre voix forte ne provient de la même direction. L'équipe a mis en open source leur code et leur jeu de données afin de faciliter les travaux de recherche futurs pour améliorer l'audition de la parole cible. Outillage Utiliser LLM pour migrer du framework de testing https://www.infoq.com/news/2024/06/slack-automatic-test-conversion/ Slack a migré 15.000 tests de Enzyme à React Testing Library avec un succès de 80% Migration nécessaire pour le manque de support de Enzyme pour React 18 L'équipe a essayé d'automatiser la conversion avec des transformations AST, mais n'a atteint que 45 % de succès à cause de la complexité des méthodes d'Enzyme et du manque d'accès aux informations contextuelles du DOM. L'équipe a utilisé Claude 2.1 pour la conversion, avec des taux de réussite variant de 40 % à 60 %, les résultats dépendant largement de la complexité des tâches. Suite aux résultats insatisfaisants, l'équipe a décidé d'observer comment les développeurs humains abordaient la conversion des tests unitaires. Les développeurs humains utilisaient leurs connaissances sur React, Enzyme et RTL, ainsi que le contexte du rendu et les conversions AST de l'outil initial pour mieux convertir les tests unitaires. Finalement les ingénieurs de Slack ont combiné transformations AST et LLM en intégrant des composants React rendus et des conversions AST dans les invites, atteignant un taux de réussite de 80 % démontrant ainsi la complémentarité de ces technologies. Claude 2.1 est un modèle de langage de grande taille (LLM) annoncé en novembre 2023 par Anthropic. Il inclut une fenêtre contextuelle de 200 000 tokens, des réductions significatives des taux d'hallucination du modèle, des invites système et permet l'utilisation d'outils. Depuis, Anthropic a introduit la famille de modèles Claude 3, composée de trois modèles distincts, avec des capacités multimodales et une compréhension contextuelle améliorée. Un arbre de syntaxe abstraite (AST) est une représentation arborescente de la structure syntaxique abstraite du code source écrit dans un langage de programmation. Chaque nœud de l'arbre représente une construction du code source. Un arbre de syntaxe se concentre sur la structure et le contenu nécessaires pour comprendre la fonctionnalité du code. Les AST sont couramment utilisés dans les compilateurs et les interpreters pour analyser et examiner le code, permettant diverses transformations, optimisations et traductions lors de la compilation. IDE de test de JetBrains https://blog.jetbrains.com/qa/2024/05/aqua-general-availability/ Aqua, le premier IDE conçu pour l'automatisation des tests, supporte plusieurs langages (Java, Python, JavaScript, TypeScript, Kotlin, SQL) et frameworks de tests (Selenium, Playwright, Cypress). Pourquoi ? Les tests d'applications nécessitent des compétences spécifiques. Aqua, un IDE adapté, est recommandé par les ingénieurs en automatisation des tests. Aqua propose deux plans de licence : un gratuit pour les usages non commerciaux et un payant pour les usages commerciaux. cam me parait un peu contre intuitif a l'heure du devops et du TDD de faire des outils dédiés et donc des equipes ou personnes dédiées Méthodologies Les 10 principes à suivre, selon le créateur de cURL, pour être un bon BDFL (Benevolent Dictator For Life) https://daniel.haxx.se/blog/2024/05/27/my-bdfl-guiding-principles/ Être ouvert et amical Livrer des produits solides comme le roc Être un leader de l'Open Source Privilégier la sécurité Fournir une documentation de premier ordre Rester indépendant Répondre rapidement Suivre l'actualité Rester à la pointe de la technologie Respecter les retours d'information Dans un vieil article de Artima, Guido Van Rossum, le créateur de Python et premier BDFL d'un projet, se remémore un échange de 1995 qui est à l'origine de ce concept https://www.artima.com/weblogs/viewpost.jsp?thread=235725 Guido Van Rossum a été le premier à endosser ce “rôle” Un site compréhensif sur les build reproductibles https://reproducible-builds.org longue doc de la definition aux méthodes pour resoudre des problèmes spécifiques Masterclass de Fabien Olicard: Le Palais Mental https://www.youtube.com/watch?v=u6wu_iY4xd8 Technique pour retenir de l'information plus longtemps que dans sa mémoire courte Les APIs web ne devraient pas rediriger HTTP vers HTTPS https://jviide.iki.fi/http-redirects grosso modo le risque majeur est d'envoyer des données confidentielles en clair sur le réseau le mieux serait de ne pas rediriger vers HTTPS, mais par contre de retourner une vraie erreur explicite notamment les clés d'API et c'est facile de ne pas le,voir vu les redirects. Sécurité Blog de GitHub sur la provenance et l'attestation https://github.blog/2024-04-30-where-does-your-software-really-come-from/ Discute les concepts de securisation de chainne d'approvisionnement de sogiciel et comment elles s'articulent entre elle. A haut niveau discute les hash pour garantir le meme fichier La signature asymetrique pour prouver que j'ai signé (e.g. le hash) et donc que je garantis. L'attenstation qui declare des faits sur un artifact attestation de provenance: source code et instructions de build (SLSA provenance) mais il faut garantir les signature avec une autorite de certification et avec des certificats a courte vide idealement, c'est sigstore MEtionne aussi The Update Framework pour s'appuyer sur cela et garantir des undates non compromis Keycloak 25 est sorti https://www.keycloak.org/2024/06/keycloak-2500-released.html Argon2 pour le hashing de mots de passe Depreciation des adaptateurs (Tomcat, servlet etc) Java 21 et depreciation de Java 17 session utilisatur persistente meme pour les instances online (pour survivre a une rotation de keycloak ameliorations autour des passkeys management et health endpoint sur un port different Et plus Demande aux cast codeurs A 40 ans, tu peux encore être codeur reconnu ? Conférences La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs : 12-14 juin 2024 : Rencontres R - Vannes (France) 13-14 juin 2024 : Agile Tour Toulouse - Toulouse (France) 14 juin 2024 : DevQuest - Niort (France) 18 juin 2024 : Mobilis In Mobile 2024 - Nantes (France) 18 juin 2024 : BSides Strasbourg 2024 - Strasbourg (France) 18 juin 2024 : Tech & Wine 2024 - Lyon (France) 19-20 juin 2024 : AI_dev: Open Source GenAI & ML Summit Europe - Paris (France) 19-21 juin 2024 : Devoxx Poland - Krakow (Poland) 26-28 juin 2024 : Breizhcamp 2024 - Rennes (France) 27 juin 2024 : DotJS - Paris (France) 27-28 juin 2024 : Agi Lille - Lille (France) 4-5 juillet 2024 : Sunny Tech - Montpellier (France) 8-10 juillet 2024 : Riviera DEV - Sophia Antipolis (France) 6 septembre 2024 : JUG Summer Camp - La Rochelle (France) 6-7 septembre 2024 : Agile Pays Basque - Bidart (France) 17 septembre 2024 : We Love Speed - Nantes (France) 17-18 septembre 2024 : Agile en Seine 2024 - Issy-les-Moulineaux (France) 19-20 septembre 2024 : API Platform Conference - Lille (France) & Online 25-26 septembre 2024 : PyData Paris - Paris (France) 26 septembre 2024 : Agile Tour Sophia-Antipolis 2024 - Biot (France) 2-4 octobre 2024 : Devoxx Morocco - Marrakech (Morocco) 7-11 octobre 2024 : Devoxx Belgium - Antwerp (Belgium) 8 octobre 2024 : Red Hat Summit: Connect 2024 - Paris (France) 10 octobre 2024 : Cloud Nord - Lille (France) 10-11 octobre 2024 : Volcamp - Clermont-Ferrand (France) 10-11 octobre 2024 : Forum PHP - Marne-la-Vallée (France) 11-12 octobre 2024 : SecSea2k24 - La Ciotat (France) 16 octobre 2024 : DotPy - Paris (France) 17-18 octobre 2024 : DevFest Nantes - Nantes (France) 17-18 octobre 2024 : DotAI - Paris (France) 30-31 octobre 2024 : Agile Tour Nantais 2024 - Nantes (France) 30-31 octobre 2024 : Agile Tour Bordeaux 2024 - Bordeaux (France) 31 octobre 2024-3 novembre 2024 : PyCon.FR - Strasbourg (France) 6 novembre 2024 : Master Dev De France - Paris (France) 7 novembre 2024 : DevFest Toulouse - Toulouse (France) 8 novembre 2024 : BDX I/O - Bordeaux (France) 13-14 novembre 2024 : Agile Tour Rennes 2024 - Rennes (France) 20-22 novembre 2024 : Agile Grenoble 2024 - Grenoble (France) 21 novembre 2024 : DevFest Strasbourg - Strasbourg (France) 27-28 novembre 2024 : Cloud Expo Europe - Paris (France) 28 novembre 2024 : Who Run The Tech ? - Rennes (France) 3-5 décembre 2024 : APIdays Paris - Paris (France) 4-5 décembre 2024 : DevOpsDays Paris - Paris (France) 4-5 décembre 2024 : Open Source Experience - Paris (France) 6 décembre 2024 : DevFest Dijon - Dijon (France) 22-25 janvier 2025 : SnowCamp 2025 - Grenoble (France) 16-18 avril 2025 : Devoxx France - Paris (France) Nous contacter Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs Contactez-nous via twitter https://twitter.com/lescastcodeurs Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

Topics covered in this episode: Make Each Line Count, Keeping Things Simple in Python Parsel A Comprehensive Guide to Python Logging with Structlog Stamina Extras Joke Watch on YouTube About the show Sponsored by Sentry: pythonbytes.fm/sentry Connect with the hosts Michael: @mkennedy@fosstodon.org Brian: @brianokken@fosstodon.org Show: @pythonbytes@fosstodon.org Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesdays at 11am PT. Older video versions available there too. Brian #1: Make Each Line Count, Keeping Things Simple in Python Bob Belderbos Some great tips to help you simplify your Python code to make it more understandable and maintainable. Michael #2: Parsel Parsel is a BSD-licensed Python library to extract data from HTML, JSON, and XML documents. Parsel lets you extract data from XML/HTML documents using XPath or CSS selectors. It supports: CSS and XPath expressions for HTML and XML documents JMESPath expressions for JSON documents Regular expressions # Want a RSS feed detail from a website standard HTML? selector = parsel.Selector(text=html_text) for link in selector.css('head > link'): rel = link.xpath('.//@rel').get() rel_type = link.xpath('.//@type').get() href = link.xpath('.//@href').get() Brian #3: A Comprehensive Guide to Python Logging with Structlog Stanley Ulili structlog is an awesome logging tool, and already has great documentation. However, this article is a great starting point, highlighting: how easy it is to get started using structlog configuring the default log level changing the formatting customizing the time stamp adding custom fields adding contextual data filtering async … Michael #4: Stamina via Matthias Bach, by Hynek Production-grade Retries Made Easy stamina is an opinionated wrapper around the great-but-unopinionated Tenacity package. Its goal is to be as ergonomic as possible, while doing the right thing by default, while minimizing potential for misuse. General additions on top of Tenacity Retry only on certain exceptions. Exponential backoff with jitter between retries. Limit the number of retries and total time. Automatic async support. Preserve type hints of the decorated callable. Count (Prometheus) and log (structlog) retries with basic metadata, if they're installed. Easy global deactivation for testing. Extras Brian: The “pytest fixtures” chapter of the pytest course is available now. Also, the PYTHONBYTES 20% discount still active for bundle through the end of August. Michael: Python 3.12.0 release candidate 1 released PyCon UK: The conference takes place from the 22nd to the 25th of September in Cardiff, Wales. The schedule is available at 2023.pyconuk.org/schedule/ and tickets are available at 2023.pyconuk.org/tickets/. PyData Eindhoven 2023, Nov 30 CFP open PyData Seattle Language Creators Charity Fundraiser: Adele Goldberg - Smalltalk, Guido Van Rossum, Anders Hejlsberg, C#, and James Gosling - Java. September 19, 2023: 12:00 - 4:00 PM, in person only. Joke: Librarian chatgpt-failures

In unserer Artikelreihe „Developer Stories“ stellen wir regelmäßig spannende Microsoft-Entwickler*innen und ihre Projekte vor. Dieses Mal mit Guido van Rossum, Distiguished Engineer und Python-Erfinder. Den Textbeitrag dazu gibt es hier: https://news.microsoft.com/de-de/developer-stories-guido-van-rossum/

We reflect on the recent musings of Python's creator, from the functional to the philosophical.

Guido van Rossum is the creator of Python programming language. Please support this podcast by checking out our sponsors: – GiveDirectly: https://givedirectly.org/lex to get gift matched up to $1000 – Eight Sleep: https://www.eightsleep.com/lex to get special savings – Fundrise: https://fundrise.com/lex – InsideTracker: https://insidetracker.com/lex to get 20% off – Athletic Greens: https://athleticgreens.com/lex to get 1 month of fish oil EPISODE LINKS: Guido's Twitter: https://twitter.com/gvanrossum Guido's Website: https://gvanrossum.github.io/ Python's Website: https://python.org PODCAST INFO: Podcast website: https://lexfridman.com/podcast Apple Podcasts: https://apple.co/2lwqZIr Spotify: https://spoti.fi/2nEwCF8 RSS: https://lexfridman.com/feed/podcast/ YouTube Full Episodes: https://youtube.com/lexfridman YouTube Clips: https://youtube.com/lexclips SUPPORT & CONNECT: – Check out the sponsors above, it's the best

Rock icon Rivers Cuomo goes deep on coding talk with Python computer language creator and programming icon, Guido Van Rossum. We talk about the history of The Sweater Song, coding vs songwriting, the history of Python and much, much more!

In the latest episode of Lexman's Artificial Podcast, Guido van Rossum joins the cast to chat about the brightness of ultramicroscopes and variations in ringhals.

On this episode of Lexman, the artificial podcast host, we talk to famed computer scientist and inventor Guido van Rossum about his new book, Saunters: The Evolution of Walking. In this book, van Rossum takes us on an exploration of the evolutionary origins of walking, from the earliest saunters to the more recent ways humanity walks. He discusses the key forces that have shaped walking over evolutionary time, as well as the ways in which contemporary walking technology reflects these forces. In a fascinating and wide-ranging interview, van Rossum shares his views on Darwinism, intromitter behavior, and the meaning of

Lexman hears that Guido van Rossum, the creator of Python, is visiting Philadelphia. Lexman interviews Van Rossum about his favorite things, specifically Boeser and physiques.

Lexman and van Rossum discuss the relationship between Leibniz and poetastering.

In this episode, Lexman interviews Predictrix founder Guido van Rossum about betrothal and recapture. Guido shares his thoughts on the often-misunderstood topic, and offers a few interesting insights. -------------------------------------------------------------------------------------------- In the digital world, things can move quickly. Yesterday's idea might be tomorrow's reality. This can be both good and bad... But Especially Bad. :-) For example, you might be a software developer and think that recapture is something that only exists in old-school (non-digital) worlds. Turns out, you're wrong! There's a lot of exciting recapture going on in

Van Rossum discusses the Arrhenius equation, proposing that it applies to economic behavior; discusses the issue of mulcting in markets; and provides a brief history of the Walloons.

Lexman interviews the creator of Python, Guido van Rossum. They discuss the drugget, quittors, granger and cingulum models.

A guide to the free software you'll need to install to get started with Python. We'll talk about Powershell, Python virtual environments, VS Code, vim, and more.We'll also talk a little bit about the history of Python and Java, why Python is enjoying a boom in popularity, and what you should see in Guido Van Rossum's home town.

Guido van Rossum, the creator of the Python programming language, joins Lexman to talk about the history and use of compilers, and the unique challenges they present. They also discuss van Rossum's favorite topic: calamuses.

Guido van Rossum, a computer scientist and co-founder of Ethereum, discusses goutte, a medical condition in which there is a sharp increase in uric acid levels.

Lexman and Guido discuss their favorite suppertimes, and how they deal with biases. They also touch on the difficulty of creating impartial opinions, and how to overcome them.

Con la renuncia del dictador benevolente de por vida, la evolución de Python cambió para siempre. El mensaje titulado "Transferencia de poder" resalta la manera en que evolucionan los lenguajes de programación. En este episodio, Emily Morehouse analiza la relación entre la expansibilidad de Python y su comunidad incluyente. Michael Kennedy explica que aunque Python es muy fácil de usar, tiene la capacidad suficiente para desarrollar cosas como YouTube e Instagram. Y Diane Mueller señala que la comunidad de Python tuvo la iniciativa de desarrollar muchas prácticas incluyentes que se han ido extendiendo en el mundo de la tecnología, como la posibilidad de tomar decisiones en comunidad, por ejemplo. Hay veces en que un dictador benevolente empieza el desarrollo de los lenguajes. Pero Python nos enseña que lo que los lleva al éxito son las comunidades. Aquí te dejamos los links a los podcasts de Michael Kennedy: Talk Python to Me y Python Bytes. 

Guido van Rossum is the creator of the Python programming language and a Distinguished Engineer at Microsoft. Apple Podcasts | Spotify | Google PodcastsWe discuss Guido’s new work on making CPython faster (PEP 659), Tiers of Python Interpreter Execution, and high impact, low hanging fruit performance improvements.Highlights(an edited summary)[00:21] What got you interested in working on Python performance?Guido: In some sense, it was probably a topic that was fairly comfortable to me because it means working with a core of Python, where I still feel I know my way around. When I started at Microsoft, I briefly looked at Azure but realized I never enjoyed that kind of work at Google or Dropbox. Then I looked at Machine Learning, but it would take a lot of time to do something interested with the non-Python, and even Python-related bits.[02:31] What was different about the set of Mark Shannon’s ideas on Python performance that convinced you to go after them?Guido: I liked how he was thinking about the problem. Most of the other approaches around Python performance like PyPy and Cinder are not suitable for all use cases since they aren’t backward compatible with extension modules. Mark has the perspective and experience of a CPython developer, as well as a viable approach that would maintain backward compatibility, which is the hardest problem to solve. The Python Bytecode interpreter is modified often across minor releases (for eg: 3.8 → 3.9) for various reasons like new opcodes, so modifying that is a relatively safe approach. Utsav: [09:45] Could you walk us through the idea of the tiers of execution of the Python Interpreter?Guido: When you execute a program, you don't know if it's going to crash after running a fraction of a millisecond, or whether it's going to be a three-week-long computation. Because it could be the same code, just in the first case, it has a bug. And so, if it takes three weeks to run the program, maybe it would make sense to spend half an hour ahead of time optimizing all the code that's going to be run. But obviously, especially in dynamic languages like Python, where we do as much as we can without asking the user to tell us exactly how they need it done, you just want to start executing code as quickly as you can. So that if it's a small script, or a large program that happens to fail early, or just exits early for a good reason, you don't spend any time being distracted by optimizing all that code.So, what we try to do there is keep the bytecode compiler simple so that we get to execute the beginning of the code as soon as possible. If we see that certain functions are being executed many times over, then we call that a hot function, and some definition of “hot”. For some purposes, maybe it's a hot function if it gets called more than once, or more than twice, or more than 10 times. For other purposes, you want to be more conservative, and you can say, “Well, it's only hot if it's been called 1000 times.”The specializing adaptive compiler (PEP 659) then tries to replace certain bytecodes with bytecodes that are faster, but only work if the types of the arguments are specific types. A simple hypothetical example is the plus operator in Python. It can add lots of things like integers, strings, lists, or even tuples. On the other hand, you can't add an integer to a string. So, the optimization step - often called quickening, but usually in our context, we call it specializing - is to have a separate “binary add” integer bytecode, a second-tier bytecode hidden from the user. This opcode assumes that both of its arguments are actual Python integer objects, reaches directly into those objects to find the values, adds those values together in machine registers, and pushes the result back on the stack. The binary adds integer operation still has to make a type check on the arguments. So, it's not completely free but a type check can be implemented much faster than a sort of completely generic object-oriented dispatch, like what normally happens for most generic add operations. Finally, it's always possible that a function is called millions of times with integer arguments, and then suddenly a piece of data calls it with a floating-point argument, or something worse. At that point, the interpreter will simply execute the original bytecode. That's an important part so that you still have the full Python semantics.Utsav [18:20] Generally you hear of these techniques in the context of JIT, a Just-In-Time compiler, but that’s not being implemented right now.Just-In-Time compilation has a whole bunch of emotional baggage with it at this point that we're trying to avoid. In our case, it’s unclear what and when we’re exactly compiling. At some point ahead of program execution, we compile your source code into bytecode. Then we translate the bytecode into specialized bytecode. I mean, everything happens at some point during runtime, so which part would you call Just-In-Time? Also, it’s often assumed that Just-In-Time compilation automatically makes all your code better. Unfortunately, you often can't actually predict what the performance of your code is going to be. And we have enough of that with modern CPUs and their fantastic branch prediction. For example, we write code in a way that we think will clearly reduce the number of memory accesses. When we benchmark it, we find that it runs just as fast as the old unoptimized code because the CPU figured out access patterns without any of our help. I wish I knew what went on in modern CPUs when it comes to branch prediction and inline caching because that is absolute magic. Full TranscriptUtsav: [00:14] Thank you, Guido, for joining me on another episode of the Software at Scale podcast. It's great to have you here. Guido: [00:20] Great to be here on the show. Utsav: [00:21] Yeah. And it's just fun to talk to you again. So, the last time we spoke was at Dropbox many, many years ago. And you got retired, and then you decided that you wanted to do something new. And you work on performance now at Microsoft, and that's amazing. So, to start off with, I just want to ask you, you could pick any project that you wanted to, based on some slides that I've seen. So, what got you interested in working on Python performance?Guido: [00:47] In some sense, it was probably a topic that was fairly comfortable to me because it means working with a core of Python, where I still feel I know my way around. Some other things I considered briefly in my first month at Microsoft, I looked into, “Well, what can I do with Azure?”, and I almost immediately remembered that I was not cut out to be a cloud engineer. That was never the fun part of my job at Dropbox. It wasn't the fun part of my job before that at Google either. And it wouldn't be any fun to do that at Microsoft. So, I gave up on that quickly. I looked in machine learning, which I knew absolutely nothing about when I joined Microsoft. I still know nothing, but I've at least sat through a brief course and talked to a bunch of people who know a lot about it. And my conclusion was actually that it's a huge field. It is mostly mathematics and statistics and there is very little Python content in the field. And it would take me years to do anything interesting with the non-Python part and probably even with the Python part, given that people just write very simple functions and classes, at best in their machine learning code. But at least I know a bit more about the terminology that people use. And when people say kernel, I now know what they mean. Or at least I'm not confused anymore as I was before.Utsav: [02:31] That makes sense. And that is very similar to my experience with machine learning. Okay, so then you decided that you want to work on Python performance, right? And then you are probably familiar with Mark Shannon's ideas?Guido: [02:43] Very much so. Yeah.Utsav: [02:44] Yeah. So, was there anything different about the set of ideas that you decided that this makes sense and I should work on a project to implement these ideas?Guido: [02:55] Mark Shannon's ideas are not unique, perhaps, but I know he's been working on for a long time. I remember many years ago, I went to one of the earlier Python UK conferences, where he gave a talk about his PhD work, which was also about making Python faster. And over the years, he's never stopped thinking about it. And he sort of has a holistic attitude about it. Obviously, the results remain to be seen, but I liked what he was saying about how he was thinking about it. And if you take PyPy, it has always sounded like PyPy is sort of a magical solution that only a few people in the world understand how it works. And those people built that and then decided to do other things. And then they left it to a team of engineers to solve the real problems with PyPy, which are all in the realm of compatibility with extension modules. And they never really solved that. [04:09] So you may remember that there was some usage of PyPy at Dropbox because there was one tiny process where someone had discovered that PyPy was actually so much faster that it was worth it. But it had to run in its own little process and there was no maintenance. And it was a pain, of course, to make sure that there was a version of PyPy available on every machine. Because for the main Dropbox application, we could never switch to PyPy because that depended on 100 different extension modules. And just testing all that code would take forever. [04:49] I think since we're talking about Dropbox, Pyston was also an interesting example. They've come back actually; you've probably heard that. The Pyston people were much more pragmatic, and they've learned from PyPy’s failures. [05:04] But they have always taken this attitude of, again, “we're going to start with CPython,” which is good because that way they are sort of guaranteed compatibility with extension modules. But still, they make these huge sets of changes, at least Pyston one, and they had to roll back a whole bunch of things because, again, of compatibility issues, where I think one of the things, they had a bunch of very interesting improvements to the garbage collection. I think they got rid of the reference counting, though. And because of that, the behavior of many real-world Python programs was completely changed. [05:53] So why do I think that Mark's work will be different or Mark's ideas? Well, for one, because Mark has been in Python core developer for a long time. And so, he knows what we're up against. He knows how careful we have with backwards compatibility. And he knows that we cannot just say get rid of reference counting or change the object layout. Like there was a project that was recently released by Facebook basically, was born dead, or at least it was revealed to the world in its dead form, CI Python (Cinder), which was a significantly faster Python implementation, but using sort of many of the optimizations came from changes in object layout that just aren't compatible with extension modules. And Mark has sort of carved out these ideas that work on the bytecode interpreter itself. [06:58] Now, the bytecode is something where we know that it's not going to sort of affect third-party extension modules too much if we change it, because the bytecode changes in every Python release. And internals of the interpreter of the bytecode interpreter, change in every Python release. And yes, we still run into the occasional issue. Every release, there is some esoteric hack that someone is using that breaks. And they file an issue in the bug tracker because they don't want to research or they haven't yet researched what exactly is the root cause of the problem, because all they know is their users say, “My program worked in Python 3.7, and it broke in Python 3.8. So clearly, Python 3.8 broke something.” And since it only breaks when we're using Library X, it must be maybe Library X's fault. But Library X, the maintainers don't know exactly what's going on because the user just says it doesn't work or give them a thousand-line traceback. And they bounce it back to core Python, and they say, “Python 3.8 broke our library for all our users, or 10% of our users,” or whatever. [08:16] And it takes a long time to find out, “Oh, yeah, they're just poking inside one of the standard objects, using maybe information they gleaned from internal headers, or they're calling a C API that starts with an underscore.” And you're not supposed to do that. Well, you can do that but then you pay the price, which is you have to fix your code at every next Python release. And in between, sort of for bug fix releases like if you go from 3.8.0 to 3.8.1, all the way up to 3.8.9, we guarantee a lot more - the bytecodes stay stable. But 3.9 may break all your hacks and it changes the bytecode. One thing we did I think in 3.10, was all the jumps in the bytecode are now counted in instructions rather than bytes, and instructions are two bytes. Otherwise, the instruction format is the same, but all the jumps jump a different distance if you don't update your bytecode. And of course, the Python bytecode compiler knows about this. But people who generate their own bytecode as a sort of the ultimate Python hack would suffer.Utsav: [09:30] So the biggest challenge by far is backwards compatibility.Guido: [09:34] It always is. Yeah, everybody wants their Python to be faster until they find out that making it faster also breaks some corner case in their code.Utsav: [09:45] So maybe you can walk us through the idea of the tiers of execution or tiers of the Python interpreter that have been described in some of those slides.Guido: [09:54] Yeah, so that is a fairly arbitrary set of goals that you can use for most interpreted languages. Guido: [10:02] And it's actually a useful way to think about it. And it's something that we sort of plan to implement, it's not that there are actually currently tiers like that. At best, we have two tiers, and they don't map perfectly to what you saw in that document. But the basic idea is-- I think this also is implemented in .NET Core. But again, I don't know if it's sort of something documented, or if it's just this is how their optimizer works. So, when you just start executing a program, you don't know if it's going to crash after running a fraction of a millisecond, or whether it's going to be a three-week-long computation. Because it could be the same code, just in the first case, it has a bug. And so, if it takes three weeks to run the program, maybe it would make sense to spend half an hour ahead of time optimizing all the code that's going to be run. But obviously, especially in dynamic language, and something like Python, where we do as much as we can without asking the user to tell us exactly how they need it done, you just want to start executing the code as quickly as you can. So that if it's a small script, or a large program that happens to fail early, or just exits early for a good reason, you don't spend any time being distracted by optimizing all that code. [11:38] And so if this was a statically compiled language, the user would have to specify that basically, when they run the compiler, they say, “Well, run a sort of optimize for speed or optimize for time, or O2, O3 or maybe optimized for debugging O0.” In Python, we try not to bother the user with those decisions. So, you have to generate bytecode before you can execute even the first line of code. So, what we try to do there is keep the bytecode compiler simple, keep the bytecode interpreter simple, so that we get to execute the beginning of the code as soon as possible. If we see that certain functions are being executed many times over, then we call that a hot function, and you can sort of define what's hot. For some purposes, maybe it's a hot function if it gets called more than once, or more than twice, or more than 10 times. For other purposes, you want to be more conservative, and you can say, “Well, it's only hot if it's been called 1000 times.” [12:48] But anyway, for a hot function, you want to do more work. And so, the specializing adaptive compiler, at that point, tries to replace certain bytecodes with bytecodes that are faster, but that work only if the types of the arguments are specific types. A simple example but pretty hypothetical is the plus operator in Python at least, can add lots of things. It can add integers, it can add floats, it can add strings, it can list or tuples. On the other hand, you can't add an integer to a string, for example. So, what we do there, the optimization step - and it's also called quickening, but usually in our context, we call it specializing - is we have a separate binary add integer bytecode. And it's sort of a second-tier bytecode that is hidden from the user. If the user asked for the disassembly of their function, they will never see binary add integer, they will also always see just binary add. But what the interpreter sees once the function has been quickened, the interpreter may see binary add integers. And the binary add integer just assumes that both of its arguments, that's both the numbers on the stack, are actual Python integer objects. It just reaches directly into those objects to find the values, adds those values together in machine registers, and push the result back on the stack. [14:35] Now, there are all sorts of things that make that difficult to do. For example, if the value doesn't fit in a register for the result, or either of the input values, or maybe even though you expected it was going to be adding two integers, this particular time it's going to add to an integer and a floating-point or maybe even two strings. [15:00] So the first stage of specialization is actually… I'm blanking out on the term, but there is an intermediate step where we record the types of arguments. And during that intermediate step, the bytecode actually executes slightly slower than the default bytecode. But that only happens for a few executions of a function because then it knows this place is always called with integers on the stack, this place is always called with strings on the stack, and maybe this place, we still don't know or it's a mixed bag. And so then, the one where every time it was called during this recording phase, it was two integers, we replace it with that binary add integer operation. The binary adds integer operation, then, before it reaches into the object, still has to make a type check on the arguments. So, it's not completely free but a type check can be implemented much faster than a sort of completely generic object-oriented dispatch, like what normally happens for the most generic binary add operations. [16:14] So once we've recorded the types, we specialize it based on the types, and the interpreter then puts in guards. So, the interpreter code for the specialized instruction has guards that check whether all the conditions that will make the specialized instruction work, are actually met. If one of the conditions is not met, it's not going to fail, it's just going to execute the original bytecode. So, it's going to fall back to the slow path rather than failing. That's an important part so that you still have the full Python semantics. And it's always possible that a function is called hundreds or millions of times with integer arguments, and then suddenly a piece of data calls it with a floating-point argument, or something worse. And the semantics still say, “Well, then it has to do with the floating-point way.Utsav: [17:12] It has to deoptimize, in a sense.Guido: [17:14] Yeah. And there are various counters in all the mechanisms where, if you encounter something that fails the guard once, that doesn't deoptimize the whole instruction. But if you sort of keep encountering mismatches of the guards, then eventually, the specialized instruction is just deoptimized and we go back to, “Oh, yeah, we'll just do it the slow way because the slow way is apparently the fastest, we can do.” Utsav: [17:45] It's kind of like branch prediction.Guido: [17:47] I wish I knew what went on in modern CPUs when it comes to branch prediction and inline caching because that is absolute magic. And it's actually one of the things we're up against with this project, because we write code in a way that we think will clearly reduce the number of memory accesses, for example. And when we benchmark it, we find that it runs just as fast as the old unoptimized code because the CPU figured it out without any of our help. Utsav: [18:20] Yeah. I mean, these techniques, generally you hear them in a context of JIT, a Just-In-Time compiler, but y’all are not implementing that right now.Guido: [18:30] JIT is like, yeah, in our case, it would be a misnomer. What we do expect to eventually be doing is, in addition to specialization, we may be generating machine code. That's probably going to be well past 3.11, maybe past 3.12. So, the release that we still have until October next year is going to be 3.11, and that's where the specializing interpreters going to make its first entry. I don't think that we're going to do anything with machine code unless we get extremely lucky with our results halfway through the year. But eventually, that will be another tier. But I don't know, Just-In-Time compilation has a whole bunch of emotional baggage with it at this point that we're trying to avoid.Utsav: [19:25] Is it baggage from other projects trying it?Guido: [19:29] People assume that Just-In-Time compilation automatically makes all your code better. It turns out that it's not that simple. In our case, compilation is like, “What exactly is it that we compile?” At some point ahead of time, we compile your source code into bytecode. Then we translate the bytecode into specialized bytecode. I mean, everything happens at some point during runtime, so which thing would you call Just-In-Time? Guido: [20:04] So I'm not a big fan of using that term. And it usually makes people think of feats of magical optimization that have been touted by the Java community for a long time. And unfortunately, the magic is often such that you can't actually predict what the performance of your code is going to be. And we have enough of that, for example, with the modern CPUs and their fantastic branch prediction.Utsav: [20:35] Speaking of that, I saw that there's also a bunch of small wins y'all spoke about, that y’all can use to just improve performance, things like fixing the place of __dict__ in objects and changing the way integers are represented. What is just maybe one interesting story that came out of that?Guido: [20:53] Well, I would say calling Python functions is something that we actually are currently working on. And I have to say that this is not just the Microsoft team, but also other people in the core dev team, who are very excited about this and helping us in many ways. So, the idea is that in the Python interpreter, up to and including version 3.10, which is going to be released next week, actually, whenever you call a Python function, the first thing you do is create a frame object. And a frame object contains a bunch of state that is specific to that call that you're making. So, it points to the code object that represents the function that's being called, it points to the globals, it has a space for the local variables of the call, it has space for the arguments, it has space for the anonymous values on the evaluation stack. But the key thing is that it’s still a Python object. And there are some use cases where people actually inspect the Python frame objects, for example, if they want to do weird stuff with local variables. [22:18] Now, if you're a debugger, it makes total sense that you want to actually look at what are all the local variables in this frame? What are their names? What are their values and types? A debugger may even want to modify a local variable while the code is stopped in a breakpoint. That's all great. But for the execution of most code, most of the time, certainly, when you're not using a debugger, there's no reason that that frame needs to be a Python object. Because a Python object has a header, it has a reference count, it has a type, it is allocated as its own small segment of memory on the heap. It's all fairly inefficient. Also, if you call a function, then you create a few objects, then from that function, you call another function, all those frame objects end up scattered throughout the entire heap of the program. [23:17] What we have implemented in our version of 3.11, which is currently just the main branch of the CPython repo, is an allocation scheme where when we call a function, we still create something that holds the frame, but we allocate that in an array of frame structures. So, I can't call them frame objects because they don't have an object header, they don't have a reference count or type, it's just an array of structures. This means that unless that array runs out of space, calls can be slightly faster because you don't jump around on the heap. And allocation sort of is to allocate the next frame, you compare two pointers, and then you bump one counter, and now you have a new frame structure. And so, creation, and also deallocation of frames is faster. Frames are smaller because you don't have the object header. You also don't have the malloc overhead or the garbage collection overhead. And of course, it's backwards incompatible. So, what do we do now? Fortunately, there aren't that many ways that people access frames. And what we do is when people call an API that returns a frame object, we say, “Okay, well sure. Here's the frame in our array. Now we're going to allocate an object and we're going to copy some values to the frame object,” and we give that to the Python code. So, you can still introspect it and you can look at the locals as if nothing has changed. [25:04] But most of the time, people don't look at add frames. And this is actually an old optimization. I remember that the same idea existed in IronPython. And they did it differently. I think for them, it was like a compile-time choice when the bytecode equivalent in IronPython was generated for a function, it would dynamically make a choice whether to allocate a frame object or just a frame structure for that call. And their big bugaboo was, well, there is a function you can call sys dunder __getFrame__ and it just gives you the frame object. So, in the compiler, they were looking, were you using the exact thing named system dunder __getFrame__ and then they would say, “Oh, that's getFrame, now we're going to compile you slightly slower so you use a frame object.” We have the advantage that we can just always allocate the frame object on the fly. But we get similar benefits. And oh, yeah, I mentioned that the frame objects are allocated in array, what happens if that array runs out? Well, it's actually sort of a linked list of arrays. So, we can still create a new array of frames, like we have space for 100 or so which, in many programs, that's plenty. And if your call stack is more than 100 deep, we'll just have one discontinuity, but the semantics are still the same and we still have most of the benefits.Utsav: [26:39] Yeah, and maybe as a wrap-up question, there are a bunch of other improvements happening in the Python community for performance as well, right? There's Mypyc, which we're familiar with, which is using types, Mypy types to maybe compiled code to basically speed up. Are there any other improvements like that, that you're excited about, or you're interested in just following?Guido: [27:01] Well, Mypyc is very interesting. It gives much better performance boost, but only when you fully annotate your code and only when you actually follow the annotations precisely at runtime. In Mypy, if you say, “This function takes two integers,” and it returns an integer, then if you call it with something else, it's going to immediately blow up. It'll give you a traceback. But the standard Python semantics are that type annotations are optional, and sometimes they're white lies. And so, the types that you see at runtime may not actually be compatible with the types that were specified in the annotations. And it doesn't affect how your program executes. Unless you sort of start introspecting the annotations, your program runs exactly the same with or without annotations. [28:05] I mean, there are a couple of big holes that are in the type system, like any. And the type checker will say, “Oh, if you put any, everything is going to be fine.” And so, using that, it's very easy to have something that is passed, an object of an invalid type, and the type checker will never complain about it. And our promise is that the runtime will not complain about it either unless it really is a runtime error. Obviously, if you're somehow adding an integer to a string at runtime, it's still going to be a problem. But if you have a function that, say, computes the greatest common divisor of two numbers, which is this really cute little loop, if you define the percent operator in just the right way, you can pass in anything. I think there are examples where you can actually pass it to strings, and it will return a string without ever failing. [29:07] And so basically, Mypyc does things like the instance attributes are always represented in a compact way where there is no dunder __dict__. The best that we can do, which we are working on designing how we're actually going to do that, is make it so that if you don't look at the dunder __dict__ attribute, we don't necessarily have to store the instance attributes in a dictionary as long as we preserve the exact semantics. But if you use the dunder __dict__, at some later point, again, just like the frame objects, we have to materialize a dictionary. And Mypyc doesn't do that. It's super-fast if you don't use dunder __dict__. If you do use dunder __dict__, it just says, “dunder __dict__ not supported in this case.” [29:59] Mypyc really only compiles a small subset of the Python language. And that's great if that's the subset you're interested in. But I'm sure you can imagine how complex that is in practice for a large program.Utsav: [30:17] It reminds me of JavaScript performance when everything is working fast and then you use this one function, which you're not supposed to use to introspect an object or something, and then performance just breaks down. Guido: [30:29] Yeah, that will happen. Utsav: [30:31] But it's still super exciting. And I'm also super thankful that Python fails loudly when you try to add a number in the string, not like JavaScript,Guido: [30:41] Or PHP, or Perl.Utsav: [30:44] But yeah, thank you so much for being a guest. I think this was a lot of fun. And I think it walked through the performance improvement y’all are trying to make in an accessible way. So, I think it’s going to be useful for a lot of people. Yeah, thank you for being a guest.Guido: [30:58] My pleasure. It’s been a fun chat. Get on the email list at www.softwareatscale.dev

Questa settimana parliamo di python il linguaggio di Guido Van Rossum, lo abbiamo fatto con Roberto Gambuzzi, che dall'Irlanda ci ha raccontato le caratteristiche del famoso linguaggio rispondendo anche a domande scomode. Ma python é lento?## Links- https://ie.linkedin.com/in/gambuzzi/en## Balocchi- https://www.youtube.com/watch?v=p33CVV29OG8## Ricorda di iscriverti al gruppo telegram:https://t.me/gitbar## Supportaci suhttps://www.buymeacoffee.com/gitbar## Contatti@brainrepo su twitter o via mail a info@gitbar.it.## CreditiLe sigle sono state prodotte da MondoComputazionaleLe musiche da Blan Kytt - RSPNSweet Lullaby by Agnese ValmaggiaMonkeys Spinning Monkeys by Kevin MacLeod

Guido van Rossum is a Dutch programmer best known as the creator of the Python programming language, for which he was the "Benevolent dictator for life" (BDFL) . Come join us for an open Q/A "Ask me Anything" to get to know how PyCon was born and Guido's amazing journeyIf you are interested in joining PyCon click here: https://us.pycon.org/2021/registration/information/ [eventID:13426]

En este episodio repasamos las noticias de Noviembre, productos fallidos, roturas de internet, vulnerabilidades, ipos falopas y todo lo que paso en el mundo de la tecnología y los sistemas. Tiktok, Github, Guido Van Rossum, python, Las Toninas, noticias de internet y todo lo relacionado al sector.

In questa puntata parliamo di Docker Hub, Microsoft, Guido van Rossum, Angular e ci domandiamo che cosa significheranno per gli sviluppatori le recenti piattaforme Low/No-code.Con: Edoardo Dusi, Stefano Mainardi, Paolo Mainardi e Claudio Serena/* Newsletter */https://landing.sparkfabrik.com/continuous-delivery-newsletter/* Link e Social */https://www.sparkfabrik.com/ - @sparkfabrik

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Python creator Guido van Rossum joins Microsoft New proposed DNS security features released Zoom has new tools to secure your Zoom meetings Malware activity increases 128% in Q3 Cisco Webex vulnerabilities allow attackers to spy on meetings Google will let you opt out of smart features FCC votes to open up more Wi-Fi Spectrum How vulnerable is G.P.S.? Zoe Clelland, VP of Product & Experience at Nintex talks about Robot Process Automation and how a business can take advantage of data integration. Hosts: Louis Maresca, Brian Chee, and Curt Franklin Guest: Zoe Clelland Download or subscribe to this show at https://twit.tv/shows/this-week-in-enterprise-tech. Sponsors: LastPass.com/twit expressvpn.com/enterprise barracuda.com/enterprise

Spionerar Apple på sina användare genom sitt nya operativsystem Big Sur? Högst kontroversiellt. Vi tar även en titt på månadens nyheter från Pine64 och slår rekord i antalet Kort & Gott-punkter med FOSS North, telemetri, youtube-dl, FSF och mycket mer. Länkar: https://trevligmjukvara.se/s05e05 Stöd Trevlig Mjukvara: https://liberapay.com/TrevligMjukvara/donate

Haarlem, 1956. No, this isn't an episode about New York, we're talking Haarlem, Netherlands. Guido Van Rossum is born then, and goes on to college in Amsterdam where he gets a degree in math and computer science. He went on to work at the Centrum Wiskunde & Informatica, or CWI. Here, he worked on BSD Unix and the ABC Programming language, which had been written by Lambert Meertens, Leo Geurts, and Steven Pemberton from CWI.  He'd worked on ABC for a few years through the 1980s and started to realize some issues. It had initially been a monolithic implementation, which made it hard to implement certain new features, like being able to access file systems and functions within operating systems. But Meertens was an editor of the ALGOL 68 Report and so ABC did have a lot of the ALGOL 68 influences that are prevalent in a number of more modern languages and could compile for a number of operating systems. It was a great way to spend your 20s if you're Guido. But after some time building interpreters and operating systems, many programmers think they have some ideas for what they might do if they just… started over. Especially when they hit their 30s. And so as we turned the corner towards the increasingly big hair of the 1990s, Guido started a new hobby project over the holiday break for Christmas 1989.  He had been thinking of a new scripting language, loosely based on ABC. One that Unix and C programmers would be interested in, but maybe not as cumbersome as C had become. So he got to work on an interpreter. One that those open source type hackers might be interested in. ALGOL had been great for math, but we needed so much more flexibility in the 90s, unlike bangs. Bangs just needed Aquanet. He named his new creation Python because he loved Monty Python's Flying Circus. They had a great TV show from 1969 to 1974, and a string of movies in the 70s and early 80s. They've been popular amongst people in IT since I got into IT. Python is a funny language. It's incredibly dynamic. Like bash or a shell, we can fire it up, define a variable and echo that out on the fly. But it can also be procedural, object-oriented, or functional. And it has a standard library but is extensible so you can add libraries to do tons of new things that wouldn't make sense to be built in (and so bloat and slow down) other apps. For example, need to get started with big array processing for machine learning projects? Install TensorFlow or Numpy. Or according to your machine learning needs you have PyTorch, SciPi, Pandas, and the list goes on.  In 1994, 20 developers met at the US National Standards Bureau in Maryland, at the first workshop and the first Python evangelists were minted. It was obvious pretty quickly that the modular nature and ease of scripting, but with an ability to do incredibly complicated tasks, was something special. What was drawing this community in. Well, let's start with the philosophy, the Zen of Python as Tim Peters wrote it in 1999: Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one—and preferably only one—obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than right now.[a] If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea—let's do more of those! Those are important enough to be semi-official and can be found by entering “import this” into a python shell. Another reason python became important is that it's multi-paradigm. When I said it could be kinda' functional. Sure. Use one big old function for everything if you're moving from COBOL and just don't wanna' rethink the world. Or be overly object-oriented when you move from Java and build 800 functions to echo hello world in 800 ways. Wanna map reduce your lisp code. Bring it. Or add an extension and program in paradigms I've never heard of. The number of libraries and other ways to extend python out there is pretty much infinite.  And that extensibility was the opposite of ABC and why Python is special. This isn't to take anything away from the syntax. It's meant to be and is an easily readable language. It's very Dutch, with not a lot of frills like that. It uses white space much as the Dutch use silence. I wish it could stare at me like I was an idiot the way the Dutch often do. But alas, it doesn't have eyeballs. Wait, I think there's a library for that.  So what I meant by white space instead of punctuation is that it uses an indent instead of a curly bracket or keyword to delimit blocks of code. Increase the tabbing and you move to a new block. Many programmers do this in other languages just for readability. Python does it for code.  Basic statements included, which match or are similar to most languages, include if, for, while, try, raise, except, class, def, with, break, continue, pass, assert, yield, import and print until python 3 when that became a function. It's amazing what you can build with just a dozen and a half statements in programming. You can have more, but interpreters get slower and compilers get bigger and all that…  Python also has all the expressions you'd expect in a modern language, especial lambdas. And methods. And duck typing, or suitability for a method is determined by the properties of an object rather than the type. This can be great. Or a total pain. Which is why they'll eventually be moving to gradual typing.  The types of objects are bool, byte array, bytes, complex, dict, ellipsis (which I overuse), float, frozen set, int, list, NoneType (which I try to never use), NotImplementedType, range, set, str, and tuple so you can pop mixed tapes into a given object. Not to be confused with a thruple, but not to not be confused I guess…  Another draw of python was the cross-compiler concept. An early decision was to make python cable to talk to c. This won over the Unix and growing Linux crowds. And today we have cross-compilers for C and C++, Go, .Net, Java, R, machine code, and of course, Java.   Python 2 came in 2000. We got a garbage collection system and a few other features and 7 point releases over the next 10 years. Python 3 came in 2008 and represented a big change. It was partially backward-compatible but was the first Python release that wasn't fully backward-compatible. We have had 7 point releases in the past 10 years as well. 3 brought changes to function print, simpler syntax, moved to storing strings in unicode by default, added a range function, changed how global variables react inside for-loops, implemented a simpler set of rules for order comparisons, and much more.  At this point developers were experimenting with deploying microservices. Microservices is an a software development architecture where we build small services, perhaps just a script or a few scripts daisy chained together, that do small tasks. These are then more highly maintainable, more easily testable, often more scalable, can be edited and deployed independently, can be structured around capabilities, and each of the services can be owned by the team that created it with a contract to ensure we don't screw over other teams as we edit them.  Amazon introduced AWS Lambda in 2014 and it became clear quickly that the new micro services paradigm was accelerating the move of many SaaS-based tools to a micro services architecture. Now, teams could build in node or python or java or ruby or c# or heaven forbid Go. They could quickly stand up a small service and get teams able to consume the back end service in a way that is scalable and doesn't require standing up a server or even a virtual server, which is how we did things in EC2. The containerization concept is nothing new. We had chroot in 1979 with Unix v7 and Solaris brought us containerization in 2004. But those were more about security. Docker had shown up in 2013 and the idea of spinning up a container to run a script and give it its own library and lib container, that was special. And Amazon made it more so.  Again, libraries and modularization. And the modular nature is key for me. Let's say you need to do image processing. Pillow makes it easier to work with images of almost any image type you can think of. For example, it can display an image, convert it into different types, automatically generate thumbnails, run sooth, blur, contour, and even increase the detail. Libraries like that take a lot of the friction out of learning to display and manage images.  But Python can also create its own imagery. For example, Matplotlib generates two dimensional graphs and plots points on them. These can look as good as you want them to look and actually allows us to integrate with a ton of other systems.  Van Rossum's career wasn't all python though. He would go on to work at NIST then CNRI and Zope before ending up at Google in 2005, where he created Mondrian, a code review system. He would go to Dropbox in 2013 and retire from professional life in 2019. He stepped down as the “Benevolent dictator for life” of the Python project in 2018 and sat on the Python Steering Council for a term but is no longer involved. It's been one of the most intriguing “Transfers of power” I've seen but Python is in great hands to thrive in the future. This is the point when Python 2 was officially discontinued, and Python 3.5.x was thriving.  By thriving, as of mid-202, there are over 200,000 packages in the Python Package Index. Things from web frameworks and web scraping to automation, to graphical user interfaces, documentation, databases, analytics, networking, systems administrations, science, mobile, image management and processing. If you can think of it, there's probably a package to help you do it. And it's one of the easier languages.  Here's the thing. Python grew because of how flexible and easy it is to use. It didn't have the same amount of baggage as other languages. And that flexibility and modular nature made it great for workloads in a changing and more micro-service oriented world. Or, did it help make the world more micro-service oriented. It was a Christmas hobby project that has now ballooned into one of the most popular languages to write software in the word. You know what I did over my last holiday break? Sleep. I clearly should have watched more Monty Python so the short skits could embolden me to write a language perfect for making the programmers equivalent, smaller, more modular scripts and functions. So as we turn the corner into all the holidays in front of us, consider this while stuck at home, what hobby project can we propel forward and hopefully end up with the same type of impact Guido had. A true revolutionary in his own right.  So thank you to everyone involved in python and everyone that's contributed to those 200k+ projects. And thank you, listeners, for continuing to tun in to the history of computing podcast. We are so lucky to have you.

Sponsored by DigitalOcean: pythonbytes.fm/datadog Special guest: Guido van Rossum Brian #1: New governance model for the Django project James Bennet on DjangoProject Blog DEP 10 (Django Enhancement Proposal) Looks like it’s been in the making since at least 2018 The specifics are definitely interesting “core team” dissolved new role, “merger” with commit access only for merging pull requests. hold no decision making privileges technical decisions made in public venues “technical board” kept where necessary, but historically it’s rare. no longer elected by committers, but anyone can run and be elected by DSF individual members. More interesting to me is the rationale Grow the set of people contributing to Django Remove the barriers to participation Looking at how decisions are made anyway historically, by reviewing pull requests, and merges done by “Fellows”, paid contractors of the DSF. Specifically, taking into account the specifics of the current state of participation in Django, trying to set it up for inclusion and growth in the future, and the specifics of this project. Not trying to clone the governance of a different project. Michael #2: missingno Missing data visualization module for Python. A small toolset of flexible and easy-to-use missing data visualizations Quick visual summary of the completeness (or lack thereof) of your dataset Just call msno.matrix(collisions.sample(250)) and here’s what you’ll see: The sparkline at right summarizes the general shape of the data completeness and points out the rows with the maximum and minimum nullity in the dataset. Other visualizations are available (heat maps, bar charts, etc) The dendrogram allows you to more fully correlate variable completion, revealing trends deeper than the pairwise ones visible in the correlation heatmap. The dendrogram uses a hierarchical clustering algorithm (courtesy of scipy) to bin variables against one another by their nullity correlation. Guido #3: Announcements from the language summit. See the schedule of topics covered here. Brian #4: Codes of Conduct and Enforcement I’ve been thinking about this a lot lately. No reason. Just interesting topic, I think. Interesting the differences in CoC and enforcement clauses of different projects based on the types of interaction most likely to need enforcement. Two examples PSF Scope (focus seems to be first on events, second on online) PSF Code of Conduct being open focus on what’s best for the community acknowledging time and effort being respectful of different viewpoints and experiences showing empathy towards other community members being considerate being respectful gracefully accepting constructive criticism using welcoming and inclusive language list of inappropriate behavior PSF CoC Enforcement Procedures 2/3 majority vote among non conflicted work group members. Process for disagreement of the work group Django Scope (focus on online spaces, events seem to be covered elsewhere) Django Code of Conduct be friendly and patient be welcoming be considerate be respectful be careful in the words you choose Includes examples of harassment and exclusionary behavior that isn’t acceptable. when we disagree try to understand why Django CoC Enforcement Manual Resolution timelines in place. Aiming for resolution within a week. Unilateral authority: Any committee member may act immediately (before consensus) to end the situation if the act is ongoing or threatening. Otherwise, consensus must be reached. Otherwise, it’s turned over to the DSF board for resolution. Differences are interesting The focus on online interactions and the Django push to try to get more people involved I think are part of the need for really fast reaction times for problems, and then trying to reach consensus. The ability to bump the decision up to the DSF is interesting too. Also the 2/3 vs consensus. For other projects Looking at these two examples, why they are different, and what similarities and needs for inclusion and growth of more developers, online vs events, etc, before deciding how to enforce CoC on your project. Enforcement and quick enforcement and public statement of what enforcement looks like seems really important. Don’t ignore it. Figure out the process before you have to use it. Michael #5: Myths about Indentation Python can come across as a funky language using spacing, not { } for code blocks So let’s talk about some myths #1 Whitespace is significant in Python source code. No, not in general. Only the indentation level of your statements is significant (i.e. the whitespace at the very left of your statements). Everywhere else, whitespace is not significant and can be used as you like, just like in any other language. The exact amount of indentation doesn't matter at all, but only the relative indentation of nested blocks (relative to each other). Furthermore, the indentation level is ignored when you use explicit or implicit continuation lines. # For example: >>> foo = [ ... 'some string', ... 'another string', ... 'short string' ... ] #2 Python forces me to use a certain indentation style Yes and no. You can write the inner block all on one line if you like, therefore not having to care about indentation at all. These are equivalent >>> if 1 + 1 == 2: ... print("foo") ... print("bar") ... x = 42 >>> if 1 + 1 == 2: ... print("foo"); print("bar"); x = 42 >>> if 1 + 1 == 2: print("foo"); print("bar"); x = 42 If you decide to write the block on separate lines, then yes, Python forces you to obey its indentation rules The conclusion is: Python forces you to use indentation that you would have used anyway, unless you wanted to obfuscate the structure of the program. Seen C code like this: if (some condition) if (another condition) do_something(fancy); else this_sucks(badluck); Either the indentation is wrong, or the program is buggy. In Python, this error cannot occur. The program always does what you expect when you look at the indentation. #3 You cannot safely mix tabs and spaces in Python That's right, and you don't want that. Most good editors support transparent translation of tabs, automatic indent and dedent. It's behaving like you would expect a tab key to do, but still maintaining portability by using spaces in the file only. This is convenient and safe. #4 I just don't like it - That's perfectly OK; you're free to dislike it - But it does have a lot of advantages, and you get used to it very quickly when you seriously start programming in Python. #5 How does the compiler parse the indentation The parsing is well-defined and quite simple. Basically, changes to the indentation level are inserted as tokens into the token stream. After the lexical analysis (before parsing starts), there is no whitespace left in the list of tokens (except possibly within string literals, of course). In other words, the indentation is handled by the lexer, not by the parser. Guido #6: Parsers and LibCST - https://github.com/Instagram/LibCST Extras: Michael: Django no longer supports Python 2 AT ALL (via Adam (Codependent Codr)). April 1st this year, the 1.11 line of Django has left Long Term Support (LTS). Leaving only 2.2.12+ with exclusively Python 3 support. Quick follow up on “Coding is Googling”. I went through a recent blip of mad googling. Brian: Gotta get my talk recorded this week, deadlines Friday. A little worried. As a writer and developer, me and deadlines don’t always see eye to eye. Follow-ups from previous episodes: Got lots of help with my Mac / Windows problem and modifier keys. Thanks everyone. Simplest solution Apple→System Prefs→Keyboard→Modifier Keys, and swap control and command for my external keyboard. So far, so good. You can’t use the setuptools_scm trick to get github actions to automatically publish to Test PyPI or PyPI for Flit or Poetry projects, since the version number is a simple string in the repo. Would love to hear if anyone has a solution to this one. Otherwise I’m fine with a make or tox snippet for publishing that combines bumping the version. Guido: PyCon goes online. Python 2.7.18 was released, the last Python 2 release ever. Joke: Via https://twitter.com/derchambers/status/1226760532763410432 How can you borrow more money at the same time? With asyncIOUs!

Welcome to Episode #1 of "The DDSRY show". Python Programming Podcast - "Python is easy to learn". About Episode: Topic: Introduction To Python Programming What you will learn in this Episode? - What is the Python Programming Language? - What is an Interpreter? - What is a Compiler? - What is HIgh-Level Language? - What is Programming? - Who Created Python Programming Language? Next Episode: Click Here -> What is Python used for? About Host: DDSRY is Computer Science Student, Python Programmer, Indian Python Podcaster, and Content Creator. DDSRY Help Students to Learn Python Programming Language on Social Media. DDSRY's Social medias IDs Instagram - @DDSRY21 Facebook - @DDSRY21 Twitter - @DDSRY21 Linkedin - DDSRY Medium - @DDSRY Pinterest - DDSRY21 Tumblr - DDSRY Giphy - @DDSRY TRANSCRIPT: All right, welcome to this particular episode of the DDSRY show, you are listening to Deepak Yadav. In this episode, you are going to learn, What is Python Programming language. Let's start. When I was learning Python, the 1st question that came to my mind was, What is the Python programming language? Python is an integrated, high-level general-purpose programming language. Let me tell you first, What means by the interpreter? Interpreter means it will execute your whole program or a code one by one, line by line. Whereas the compiler will execute your whole program at a time and it will tell you where is the error? The 2nd question that came to my mind was, What means by high-level language? High-level language means a language that is closer to work, a human language like English.Python. However, one of the features is expressed. You mean so you can express your code to another programming? 3rd question came to my mind was. What is a Programming language? A programming language is a language that used to give instruction to a computer to perform a specific task, simply to give instruction to a computer, to perform a specific task. The 5th question that came to my mind was, Who created Python? Python was created by Guido Van Rossum. ---DDSRY--- What can you expect to hear every time, when you click on an episode of the DDSRY show? when you click on an episode of the DDSRY show? you will learn the python programming in the best and easy way by DDSRY. Who is this show for? Beginners. What is the goal of DDSRY with this show? To teach python programming through a podcast for free. What DDSRY is going to teach you from this podcast? Python Programming Language. About "The DDSRY Show": This show was created on 1 Feb 2020. This show is all about teaching Python Programming for free. Season #1 Episode #1 --- Send in a voice message: https://anchor.fm/the-ddsry-show/message

== Pedí tus remeras y merchandising de sysarmy == remeras[at]sysarmy.com.ar == Búsquedas laborales == Despegar: DBA https://despegar.avature.net/oportunidades/JobDetail?jobId=4541 JAVA JR/SSR/SR https://despegar.avature.net/oportunidades/JobDetail?jobId=1579 Santander: DevOps Engineer CABASE: Busca sysadmin con sólidos conocimientos de scripting y ganas de aprender networking == En este episodio == Más polémicas alrededor de WeWork, porque parece que no se terminan nunca, se develó el misterio sobre a dónde va a ir a parar AWS en Argentina, Pepe Robles el Wikipedista misterioso, se encontraron Password de algunos devs famosos en BSD, se confirma que el 2020 es el año de Linux, se retira Guido Van Rossum y seguro se pone un bar en la playa inspirado por nerdearla, y decenas de noticias y novedades mas para discutir!. == Mencionados en este episodio == Amazon en Argentina: https://www.bloomberg.com/news/articles/2019-10-03/amazon-web-services-poised-to-build-a-data-center-in-argentina El Wikipedista misterioso: https://www.infoveloz.com/post/el-lado-oscuro-de-wikipedia-quien-es-robles-pepe-el-misterioso-usuario-que-blinda-al-kirchnerismo_194204 Password en BSD: https://thehackernews.com/2019/10/unix-bsd-password-cracked.html Abogados Panama Papers vs Netflix: https://www.cronista.com/apertura-negocio/empresas/Abogados-de-Panama-Papers-demandan-a-Netflix-por-us-10.000-millones-20191016-0006.html Ubuntu Desktop new director: https://www.omgubuntu.co.uk/2019/10/canonical-has-a-new-ubuntu-desktop-director Emoji del mate para Android: https://tn.com.ar/tecno/f5/el-emoji-del-mate-ya-esta-disponible-en-whatsapp-para-android_1008546 Se retira Guido Van Rossum: https://blog.dropbox.com/topics/company/thank-you--guido 1 Petabit per Second Network Node: https://www.nict.go.jp/en/press/2019/10/17-1.html Alibaba y MongoDB: https://www.zdnet.com/article/alibaba-cloud-to-offer-mongodb-managed-service/ Fitbit a google: https://investor.fitbit.com/press/press-releases/press-release-details/2019/Fitbit-to-Be-Acquired-by-Google/default.aspx Rusia nueva ley para Internet: https://www.npr.org/2019/11/01/775366588/russian-law-takes-effect-that-gives-government-sweeping-power-over-internet Facebook cambio de logo: https://tn.com.ar/tecno/f5/facebook-cambio-su-nombre-y-por-supuesto-hay-memes_1008293 Estadísticas de trabajo remoto: https://usefyi.com/remote-work-statistics/ Tarjeta de crédito de Apple es sexista: https://www.engadget.com/2019/11/09/new-york-investigates-apple-card-credit-limit-sexism/ AI para Karaoke: https://www.theverge.com/2019/11/5/20949338/vocal-isolation-ai-machine-learning-deezer-spleeter-automated-open-source-tensorflow Gusano en Docker Engine: https://unit42.paloaltonetworks.com/graboid-first-ever-cryptojacking-worm-found-in-images-on-docker-hub/ Python segundo lenguaje en Github: https://www.theregister.co.uk/2019/11/07/python_java_github_javascript/ Github Mobile: https://twitter.com/github/status/1194675248047616000 Nueva MacBook Pro: https://www.xataka.com/ordenadores/apple-macbook-pro-16-caracteristicas-precio-ficha-tecnica https://www.apple.com/newsroom/2019/11/apple-introduces-16-inch-macbook-pro-the-worlds-best-pro-notebook/ Facebook Pay: https://www.iprofesional.com/tecnologia/303693-cuenta-transferencia-tarjeta-de-credito-Facebook-Pay-sistema-de-pagos-en-Facebook-WhastApp-Instagram-y-Messenger Facebook y las APIs otra vez: http://www.redusers.com/noticias/facebook-suministro-datos-usuarios-accidente/ Por qué SSH esta en el 22?: https://www.ssh.com/ssh/port Cerdbot for windows: https://community.letsencrypt.org/t/beta-phase-of-certbot-for-windows/105822 Superman en cristales: http://www.redusers.com/noticias/graban-la-pelicula-superman-1978-cristal-silicio/ Php vuln: https://nakedsecurity.sophos.com/2019/10/29/php-team-fixes-nasty-site-owning-remote-execution-bug/ Sudo bug: https://thehackernews.com/2019/10/linux-sudo-run-as-root-flaw.html Adobe leak: https://mashable.com/article/adobe-creative-cloud-accounts-exposed.amp Amazon Ring bug: https://techcrunch.com/2019/11/07/amazon-ring-doorbells-wifi-hackers/ Uber despide a 350 empleados: https://www.perfil.com/noticias/bloomberg/bc-uber-despide-a-350-empleados-ultima-ola-de-recortes-laborales.phtml Mirantis compra Docker: https://techcrunch.com/2019/11/13/mirantis-acquires-docker-enterprise/ Softbank compra lo que le faltaba de WeWork: https://www.iproup.com/innovacion/8370-tecnologia-innovacion-tecnologica-productos-innovadores-Es-oficial-Softbank-acordo-la-compra-de-WeWork https://twitter.com/pempek/status/1192401223472832512?s=19 Gitlab y la telemetria: https://gitlab.com/gitlab-org/gitlab/issues/34833 == Eventos y meetups == Muestra del Museo de Informática == Organizaciones amigas == Museo de Informática: http://museodeinformatica.org.ar/ Museo de Informática en Facebook: https://goo.gl/TaASu3 == Encontranos en == Web: http://sysar.my Twitter: @sysarmy Facebook: https://goo.gl/tGcpcw IRC en Freenode: #sysarmy Ivoox: https://goo.gl/GtISQ9 Pocketcast: http://pca.st/D3H0 Playerfm: http://bit.ly/polemicaenvarplayerfm iTunes: https://goo.gl/Nrt22g Spotify: http://bit.ly/polemicaenvar == Conducen este episodio == Ariel Jolo: @ajolo Jorge Abreu: @ar_jorge1987 Regina Loustau: @Rhapsody_Girl Eduardo Casarero: @jedux

See the full show notes for this episode on the website at pythonbytes.fm/155.

Microsoft open sources more code, a replacement for managing wireless networking in Linux, changes at Dropbox, and why the Conservancy would like to hear from Tesla owners.

Martijn Pieters is the world’s highest contributor to Python on Stackoverflow. Martijn has worked on developer infrastructure at Facebook; on Zope with Guido Van Rossum, the creator of Python; and on the framework team of Plone, which is used by the CIA and FBI. He has made contributions to Python, Flask, and Mercurial, and currently works as an open source consultant. In this interview Martijn tells the story of his career. We talk about working at Facebook, what motivates Martijn to answer questions on StackOverflow, and the importance of algorithms and computer science fundamentals.

A benevolent dictator for life steps down and changes the course of the Python language forever. Guido van Rossum’s “Transfer of Power” memo brings attention to the way programming languages evolve. In this episode, Emily Morehouse makes the connection between Python’s technical extensibility and its inclusive community. Michael Kennedy explains how Python is both easy to learn and powerful enough to build YouTube and Instagram. And Diane Mueller highlights how the Python community took the lead on so many inclusive practices that are spreading in tech—including the rise of community-led decision-making. Sometimes, a benevolent dictator can get a language started. But Python shows it’s communities that make languages thrive. Learn more about Python at redhat.com/commandlineheroes Also check out these Python podcasts that guest Michael Kennedy is part of — Talk Python to Me, and Python Bytes We hear from Guido van Rossum in this episode from a Computer History Museum interview.

Python is one of the most widely used programming languages. Swapnil Bhartiya, the founder of TFIR, sat down with Guido van Rossum, the creator of Python to talk about the origin of the langue and why he stepped down from the leadership of the very project he created.

Guido van Rossum is the creator of Python, one of the most popular and impactful programming languages in the world. Video version is available on YouTube. If you would like to get more information about this podcast go to https://lexfridman.com/ai or connect with @lexfridman on Twitter, LinkedIn, Facebook, or YouTube where you can watch the video versions of these conversations.

Chris is joined by Paul Smith to discuss Crystal, a statically-typed and compiled language with a Ruby inspired syntax. Paul has spent much of the past few years exploring Crystal and building a new web framework called Lucky. Paul's infectious enthusiasm for the Crystal language shines through in this discussion covering some of the unique features of Crystal & Lucky, but there is plenty to enjoy even if you're not specifically interested in Crystal. With Lucky, Paul has done a great job of taking the best of what has been built in other frameworks and bring it to Crystal, drawing inspiration from Ruby & Rails, Elixir & Phoenix, and even PHP and the Laravel framework. There's something in this episode for everyone! Crystal If You Gaze Into nil, nil Gazes Also Into You Elm Scala Elixir Elixir Phoenix Laravel Laravel Mix Lucky on GitHub Render HTML pages in Lucky Actions and Routing in Lucky Browser tests with LuckyFlow Dusk selectors Guido Van Rossum, Python BDFL, Stepping down VS Code BikeShed episode w/ German Velasco disucssing Elixir

Llegó el café informativo de sysarmy. Noticias del mundo Linux, Administración de sistemas y DevOps, mezclado con novedades sobre eventos, meetups, etc. == Pedí tus remeras y merchandising de sysarmy == remeras[at]sysarmy.com.ar == Búsquedas laborales == Sysarmy en LinkedIn: https://goo.gl/1QMlCv Medallia Systems Administrator: https://jobs.lever.co/medallia/3c3f5d... Edrans - Systems Engineer: https://www.edrans.com/#/bolsa-de-tra... Mulesoft - DevOps y Devops Manager: https://www.mulesoft.com/careers/job-... == En este episodio == Discutimos de todo, arrancando por las busquedas laborales del momento, los festejos por la adminfest, las noticias del mes, en donde repasamos algunas de las ultimas caidas de grandes empresas, el partnership de Atlassian y slack, novedades del dataceter acuatico de Microsoft, los 25 años de Wine y de Slackware, vulnerabilidades en tcp y openssh, la actualidad de Python y un repaso por los proximos eventos cerrando con una mesa llena de polémica con las invitadas especiales. == Mencionados en este episodio == Encuesta de sueldo: https://goo.gl/gqESHk Atlassian + Slack: https://www.atlassian.com/blog/announ... Microsoft Datacenter submarino: https://natick.research.microsoft.com/ Wine cumplió 25 años: https://www.theregister.co.uk/2018/07... Slackware 25 años: https://opensource.com/article/18/7/s... Problemas financieros de Pat: https://www.linuxquestions.org/questi... Y: https://www.paypal.me/volkerdi TCP stack vulnerable a DDOS: https://www.kb.cert.org/vuls/id/962459 The default OpenSSH key encryption is bad: https://latacora.singles/2018/08/03/t... Guido Van Rossum se baja como BDFL de Python: https://mail.python.org/pipermail/pyt... == Eventos y meetups == nerdear.la: 30 de agosto al 1 de septiembre: https://nerdear.la/ Museo de Informatica: Sigue la muestra Gamer. NotPinkCon: Vie 24 ago. 2018 https://www.eventbrite.es/e/entradas-... Ekoparty: 26 - 28 de septiembre https://www.ekoparty.org/ == Organizaciones == Museo de Informatica: http://museodeinformatica.org.ar/ Museo de Informatica en Facebook: https://goo.gl/TaASu3 EkoSpace: http://eko.space/ EkoSpace en Facebook: https://goo.gl/VOzYle EkoSpace en Twitter: https://goo.gl/umJHVp == Encontranos en == Web: http://sysar.my Twitter: @sysarmy Facebook: https://goo.gl/tGcpcw IRC en Freenode: #sysarmy Ivoox: https://goo.gl/GtISQ9 Pocketcast: http://pca.st/D3H0 iTunes: https://goo.gl/Nrt22g == Conducen este episodio == Ariel Jolo: @ajolo Jorge Abreu: @ar_jorge1987 == Invitadas == Vero Ovando: @verovand Regina Loustau: @Rhapsody_Girl

In this episode of Ask SME Anything: 1. Are loops necessary or will recursion suffice? 2:14 2. What is the difference between imperative and declarative programming? 7:54 3. What is object-oriented programming? 12:54 4. What are your thoughts on Guido Van Rossum stepping down as the leader of the Python community? 20:48

See the full show notes for this episode on the website at talkpython.fm/170.

See the full show notes for this episode on the website at pythonbytes.fm/87.

We ruminate on Python’s founder stepping down, and ponder if it was inevitable. Plus the topic of hardware and software workflows is back in the news, and Instapaper goes independent. So why does that feel like a bad thing?

Arch finds itself in the barrel, Ubuntu goes on a diet, and Python's leader for life has had enough, and steps down. Plus Debian joins KDE's council of wizards.

Arch finds itself in the barrel, Ubuntu goes on a diet, and Python's leader for life has had enough, and steps down. Plus Debian joins KDE's council of wizards.

Arch finds itself in the barrel, Ubuntu goes on a diet, and Python's leader for life has had enough, and steps down. Plus Debian joins KDE's council of wizards.

See the full show notes for this episode on the website at talkpython.fm/100.

Happy Thursday!  Here’s an interview with Guido van Rossum, author of the Python programming language. Download Link: https://mostlyerlang.files.wordpress.com/2015/05/interview-with-guido-van-rossum.mp3