Podcasts about code smells

News includes Hex 2.2.0 with the new :warnifoutdated option for keeping dependencies updated, Honeybadger's APM with built-in Elixir traces for major components, José Valim demonstrating Tidewave with Zed's AI coding agents, LiveDebugger v0.2.0 with DevTools integration and component highlighting, Dave Lucia's new Elixir "Lua" library for embedding Lua scripting, Paulo Valente's "handoff" library for distributed function graph execution, a PhD thesis on Elixir code smells becoming a finalist for a prestigious award, and more! Show Notes online - http://podcast.thinkingelixir.com/254 (http://podcast.thinkingelixir.com/254) Elixir Community News https://paraxial.io/ (https://paraxial.io/?utm_source=thinkingelixir&utm_medium=shownotes) – Paraxial.io is sponsoring today's show! Sign up for a free trial of Paraxial.io today and mention Thinking Elixir when you schedule a demo for a limited time offer. https://github.com/hexpm/hex/releases/tag/v2.2.0 (https://github.com/hexpm/hex/releases/tag/v2.2.0?utm_source=thinkingelixir&utm_medium=shownotes) – Hex releases 2.2.0 introducing the :warnifoutdated option to help keep dependencies updated. Taking a week off - no episode next week, but returning the following week. https://www.honeybadger.io/blog/elixir-performance-monitoring (https://www.honeybadger.io/blog/elixir-performance-monitoring?utm_source=thinkingelixir&utm_medium=shownotes) – Honeybadger now offers APM with built-in Elixir traces, including default dashboards for Ecto, Phoenix/LiveView, Oban, Absinthe, Finch, and Tesla. https://x.com/josevalim/status/1920062725394243640 (https://x.com/josevalim/status/1920062725394243640?utm_source=thinkingelixir&utm_medium=shownotes) – José Valim demonstrates Tidewave being used with Zed editor's AI coding agents. https://zed.dev/agentic (https://zed.dev/agentic?utm_source=thinkingelixir&utm_medium=shownotes) – Zed's agentic features used with Tidewave to code a pricing plan component. https://www.reddit.com/r/elixir/comments/1kgyfhb/livedebuggerv020is_out/ (https://www.reddit.com/r/elixir/comments/1kgyfhb/livedebugger_v020_is_out/?utm_source=thinkingelixir&utm_medium=shownotes) – LiveDebugger v0.2.0 released with Chrome DevTools extension, component highlighting, callback trace filtering, and dark mode. https://podcast.thinkingelixir.com/249 (https://podcast.thinkingelixir.com/249?utm_source=thinkingelixir&utm_medium=shownotes) – Previous podcast episode discussing LiveDebugger with Krzysztof. https://blog.swmansion.com/whats-new-in-livedebugger-v0-2-0-4543d3af5486 (https://blog.swmansion.com/whats-new-in-livedebugger-v0-2-0-4543d3af5486?utm_source=thinkingelixir&utm_medium=shownotes) – Blog post covering the new features in LiveDebugger v0.2.0. https://hexdocs.pm/luerl/readme.html (https://hexdocs.pm/luerl/readme.html?utm_source=thinkingelixir&utm_medium=shownotes) – Luerl v1.4.1 released with Hex docs - an implementation of Lua 5.3 in Erlang/OTP. https://github.com/rvirding/luerl (https://github.com/rvirding/luerl?utm_source=thinkingelixir&utm_medium=shownotes) – The GitHub repository for Luerl, which Dave Lucia worked on with Robert Virding. https://www.lua.org/about.html (https://www.lua.org/about.html?utm_source=thinkingelixir&utm_medium=shownotes) – Information about Lua, a lightweight, embeddable scripting language. https://bsky.app/profile/davelucia.com/post/3lozadtvqtc2m (https://bsky.app/profile/davelucia.com/post/3lozadtvqtc2m?utm_source=thinkingelixir&utm_medium=shownotes) – Dave Lucia's announcement of his new Elixir "Lua" library. https://davelucia.com/blog/lua-elixir (https://davelucia.com/blog/lua-elixir?utm_source=thinkingelixir&utm_medium=shownotes) – Blog post explaining Dave's new Elixir Lua library. https://github.com/tv-labs/lua (https://github.com/tv-labs/lua?utm_source=thinkingelixir&utm_medium=shownotes) – The GitHub repository for the new Elixir Lua library, providing an ergonomic interface to Luerl. https://hexdocs.pm/handoff/ (https://hexdocs.pm/handoff/?utm_source=thinkingelixir&utm_medium=shownotes) – Documentation for "handoff", a new Elixir library for distributed function graph execution. https://bsky.app/profile/polvalente.social/post/3louqxeegrs2u (https://bsky.app/profile/polvalente.social/post/3louqxeegrs2u?utm_source=thinkingelixir&utm_medium=shownotes) – Paulo Valente's announcement of the handoff library, which enables distributed Nx computations. https://github.com/polvalente/handoff (https://github.com/polvalente/handoff?utm_source=thinkingelixir&utm_medium=shownotes) – GitHub repository for the handoff library created by Paulo Valente and sponsored by TvLabs. https://bsky.app/profile/lucasvegi.bsky.social/post/3lke2pt2zws2e (https://bsky.app/profile/lucasvegi.bsky.social/post/3lke2pt2zws2e?utm_source=thinkingelixir&utm_medium=shownotes) – Lucas Vegi's PhD thesis "Code Smells and Refactorings for Elixir" is a finalist for the SBC Dissertation Award. https://hexdocs.pm/elixir/code-anti-patterns.html (https://hexdocs.pm/elixir/code-anti-patterns.html?utm_source=thinkingelixir&utm_medium=shownotes) – Elixir's code anti-patterns guide, a practical resource related to code smells and refactoring in Elixir. Do you have some Elixir news to share? Tell us at @ThinkingElixir (https://twitter.com/ThinkingElixir) or email at show@thinkingelixir.com (mailto:show@thinkingelixir.com) Find us online - Message the show - Bluesky (https://bsky.app/profile/thinkingelixir.com) - Message the show - X (https://x.com/ThinkingElixir) - Message the show on Fediverse - @ThinkingElixir@genserver.social (https://genserver.social/ThinkingElixir) - Email the show - show@thinkingelixir.com (mailto:show@thinkingelixir.com) - Mark Ericksen on X - @brainlid (https://x.com/brainlid) - Mark Ericksen on Bluesky - @brainlid.bsky.social (https://bsky.app/profile/brainlid.bsky.social) - Mark Ericksen on Fediverse - @brainlid@genserver.social (https://genserver.social/brainlid) - David Bernheisel on Bluesky - @david.bernheisel.com (https://bsky.app/profile/david.bernheisel.com) - David Bernheisel on Fediverse - @dbern@genserver.social (https://genserver.social/dbern)

Neste episódio do Elixir em Foco, Adolfo Neto, Herminio Torres e Zoey Passanha conversaram com Gabriel Pereira sobre o RefactorEx, uma ferramenta de refatoração de código Elixir. Gabriel é formado em Ciência da Computação pela Universidade Federal de Viçosa (UFV) e atualmente atua como Tech Lead na Ingresse, onde lidera times relacionados a pagamentos e autorizações. O RefactorEx nasceu como seu Trabalho de Conclusão de Curso e vem ganhando destaque na comunidade, tendo sido inclusive mencionado na Code BEAM America 2025 por Mitchel Hanberg. No episódio, Gabriel contou como surgiu a ideia da ferramenta, por que optou por uma extensão para o VS Code, quais são suas refatorações favoritas, a influência do trabalho de Lucas Vegi em sua pesquisa, e também um pouco sobre o uso de Elixir na Ingresse.Gabriel Pereira https://github.com/gp-pereira RefactorEx https://github.com/gp-pereira/refactorex RefactorEx - Effortless Elixir Refactoring in VS Code https://elixirforum.com/t/refactorex-effortless-elixir-refactoring-in-vs-code/67759 RefactorEx foi mencionado na Code BEAM America 2025https://x.com/adolfont/status/1898117471309369465 “REFACTOREX: Integrate Refactorex, another language server by Gabriel Pereira as a university projectImplements a ton of awesome refactors. Built with GenLSP”Refactorex demo at Elixir LSP talk by Mitchell Hanberg's Code BEAM America 2025 talkhttps://www.youtube.com/watch?v=R1CCyszhESk Expert, o novo LSP de Elixir https://expert-lsp.org/ Episódio sobre Code Smells, com Lucas Vegi e Marco Tulio Valentehttps://creators.spotify.com/pod/show/elixiremfoco/episodes/15--Elixir-Code-Smells-com-Lucas-Vegi-UFV-e-Marco-Tulio-Valente-UFMG-e1jb1bbCode Smells e Refatorações específicos para Elixir, Lucas Vegi (UFV e UFMG) - palestrahttps://youtu.be/klubcNmv4qI?si=A-V4Zz4cU_ybyVuW  E-mail do Gabriel: pereira7346@gmail.comRede Emílias de Podcasts no Bluesky - https://bsky.app/profile/redeemilias.bsky.social Rede Emílias de Podcasts no Mastodon - https://bertha.social/@redeemilias/ Elixir em Foco no YouTube - https://www.youtube.com/@elixiremfoco Elixir em Foco no Spotify - https://open.spotify.com/show/43aDX4kajkNCKaCYpGPooJ Elixir em Foco no Spotify for Podcasters - https://podcasters.spotify.com/pod/show/elixiremfoco Elixir em Foco na Apple Podcasts - https://podcasts.apple.com/us/podcast/elixir-em-foco/id1560944119 Associe-se à Erlang Ecosystem Foundation - https://bit.ly/3Sl8XTO Site da Erlang Ecosystem Foundation - https://bit.ly/3Jma95g Nosso site - https://elixiremfoco.com Nosso email - elixiremfoco@gmail.com 

Bei Software mit hunderttausend Zeilen kann man schnell den Überblick über Code, Architektur und deren Qualität verlieren. Sind wir noch auf dem richtigen Weg, blockieren wir uns mit internen Abhängigkeiten, oder sind wir schon festgefahren? Software ist immateriell, wir können nicht sehen, wie es ihr geht. Wir können uns allerdings mit Tools helfen. Eines davon ist das kostenlose Open-Source-Tool CodeCharta, das uns Richard vorstellen wird. Es bietet seit 2017 die Möglichkeit, Experten und Laien gleichermaßen die Qualität von Software nachvollziehbar zu machen. Die Idee ist sehr einfach: Wir visualisieren unsere Software als 3D-Stadtkarte (Charta = lateinisch für Karte oder Papier). Jede Datei wird zu einem Gebäude. Kleine Dateien werden zu Bungalows, komplexe Dateien stechen als Wolkenkratzer hervor. Wolkenkratzer, die nur einen Autor haben, werden rot, denn hier existiert ein Wissenssilo. Das ist nur ein kleiner Teil der Visualisierungsmöglichkeiten: CodeCharta kann auch visualisieren, welche Dateien viel verändert werden, kaum Testabdeckung haben, hohe Verschachtelungstiefe bieten oder eine hohe Anzahl an Code Smells. Die Stadt-Metapher hilft dabei Experten wie Laien gleichermaßen und ermöglicht eine verständnisvolle Diskussion. Ein Feature, dass in den New Yorker Wolkenkratzern eingebaut werden soll, wird garantiert länger dauern als eines, das in einem Bonner Bungalow platziert wird. Diese Diskussion können wir auch am physischen Objekt führen, denn eine CodeCharta kann auch in 3D drucken. Links Unconference zu Software Architektur und KI mit Lisa, Ralf und Eberhard CodeCharta Homepage CodeCharta bei GitHub Folgen zu Architektur-Management-Werkzeugen Richard bei LinkedIn Richard bei BlueSky Richards Blog

В прошлый раз мы разобрали единую метрику от Microsoft, сегодня же пройдемся по другим популярным способам запихнуть качество кода в одно число.Спасибо всем, кто нас слушает. Ждем Ваши комментарии.Бесплатный открытый курс "Rust для DotNet разработчиков": https://www.youtube.com/playlist?list=PLbxr_aGL4q3S2iE00WFPNTzKAARURZW1ZShownotes: 00:00:00 Вступление00:09:00 Зачем Cyclomatic complexity?00:27:00 Метод, который вызывается один раз, code smell?00:31:55 Code Smells метрика00:43:00 Security метрики00:46:00 Code duplicationСсылки:- https://blog.jetbrains.com/qodana/2023/10/top-6-code-quality-metrics-to-empower-your-team/ : Метрики от JetBrains- https://blog.codacy.com/code-quality-metrics : Метрики от Codacity - https://docs.sonarsource.com/sonarqube/latest/user-guide/code-metrics/metrics-definition/ : Метрики от SonarВидео: https://youtube.com/live/mqFOa9X-rcsСлушайте все выпуски: https://dotnetmore.mave.digitalYouTube: https://www.youtube.com/playlist?list=PLbxr_aGL4q3R6kfpa7Q8biS11T56cNMf5Twitch: https://www.twitch.tv/dotnetmoreОбсуждайте:- Telegram: https://t.me/dotnetmore_chatСледите за новостями:– Twitter: https://twitter.com/dotnetmore– Telegram channel: https://t.me/dotnetmoreCopyright: https://creativecommons.org/licenses/by-sa/4.0/

After a week of travel, Seth and Ken return to the podcast with a breakdown of their travel experiences at multiple conferences and teaching their first Practical Secure Code Review course using LLMs to enhance the methodology. This is followed by reinforcement of code review steps including library research, a discussion of the recent XZ backdoor, and an article reviewing LLM hallucinations when recommending libraries.

Esplora la #objectorientedprogramming , scopri i #codesmell e l' #objectcalisthenics .In questo pomodoro settimanale vediamo come questi argomenti ci aiutano a scrivere codice migliore e più pulito.#programmatore #softwaredevelopmentLink and references from the video:https://refactoring.guru/refactoring/smellshttps://github.com/dan-the-dev/object-calisthenics-rules -https://view.genial.ly/62874fa86fc0d50011469884/presentation-object-calisthenics-lessenza-oop-al-servizio-del-tdd___________________________________________________________________Discover Learn Agile Practices: https://learnagilepractices.com/Subscribe to the newsletter: https://learnagilepractices.com/subscribeJoin the free Telegram channel: https://t.me/+2QAtoLNIgVU0NmU0Need help in developing your career in Software? Discover my coaching and mentorship program: https://learnagilepractices.com/coachingFollow me: https://danthedev.carrd.co/

In dieser Episode haben wir Code Smells besprochen und wie man sie vermeidet. Dazu gehören längere Methoden, schlechte Klassennamen und unnötige Abhängigkeiten. Wir haben auch über die Verwendung von komplexen Typen und Tools wie statischer Codeanalyse gesprochen. Wichtig ist qualitativ hochwertiger Code mit guter Namensgebung und klaren Zuständigkeiten. Code-Reviews, kollaboratives Arbeiten und automatisierte Tests können helfen, Probleme frühzeitig zu erkennen.

Подкаст RadioDotNet выпуск №81 от 30 октября 2023 года Сайт подкаста: radio.dotnet.ru Boosty (₽): boosty.to/RadioDotNet Темы: [00:01:00] — Announcing .NET 8 Release Candidate 2 devblogs.microsoft.com/dotnet/announcing-dotnet-8-rc2 devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-... devblogs.microsoft.com/dotnet/announcing-ef8-rc2 devblogs.microsoft.com/dotnet/announcing-dotnet-maui-in-dotne... [00:24:18] — The convenience of System.Text.Json devblogs.microsoft.com/dotnet/the-convenience-of-system-text-... [00:37:28] — Performance Improvements in ASP.NET Core 8 devblogs.microsoft.com/dotnet/performance-improvements-in-asp... [00:48:40] — Discriminated Unions in C# blog.maartenballiauw.be/post/discriminated-unions-in-csharp [01:08:20] — Visual Studio 2022 17.8 Preview 3 devblogs.microsoft.com/visualstudio/visual-studio-2022-17-8-p... [01:09:43] — What's next in C# by Mads Torgersen youtube.com/watch [01:25:30] — Async code smells and analyzers cezarypiatek.github.io/post/async-analyzers-p1 cezarypiatek.github.io/post/async-analyzers-p2 cezarypiatek.github.io/post/async-analyzers-summary [02:02:06] — Кратко о разном github.com/waf/CSharpRepl mongodb.com/blog/post/mongodb-provider-entity-fram... andrewlock.net/exploring-the-dotnet-8-preview-short-c... youtube.com/@nickchapsas youtube.com/@keepcodingpodcast/featured Фоновая музыка: Максим Аршинов «Pensive yeti.0.1»

Does ChatGPT stink for Test automation? How can AI help you with regression testing? And what is a real-world example of using AI with RPA, DevOps, and more? Find out in this episode of the Test Guild New Shows for the week of Oct 22. So, grab your favorite cup of coffee or tea, and let's do this. Time News Title Link 0:25  Applitoools FREE Account Offer https://applitools.info/joe  0:38 AI-POWERED REGRESSION TESTING https://testguild.me/katalon 2:12 Mobile Testing Experience Summit Register https://testguild.me/ckdtml 3:12 Language Models (LLMs) have enhanced my prototyping https://testguild.me/ct5yqg 4:30 ChatGPT Sucks for Test Automation https://testguild.me/h01r8l 6:07 UiPath launches Autopilot https://testguild.me/ufr8o0 7:14 Kubiya ChatGPT-like assistant for DevOps processes https://testguild.me/qpn2g3 8:17 Terraform testing https://testguild.me/2rr1ws  

This week we talk about code smells.

Integration points in complex systems have a tendency to surprise you, usually in an unpleasant fashion. While it takes a while to discover the underlying antipatterns that caused the system to have problems, there are certain "smells" you can look for that indicate common sources of issues. Read more › The post Integration Code Smells appeared first on Complete Developer Podcast.

Diyaz Yakubov comes on the show this week to talk about a few tools he's using to make his life easier at work. We talk about NDepend - a code analyser that you can use on your IDE or CI/CD pipeline to give you recommendations on your code structure and then we move onto C4Model - a new graphical notation language and SharpLab - a neat little online code playground that can convert your code to IL or ASM. Sponsors Chuck's Resume Template Developer Book Club starting with Clean Architecture by Robert C. Martin Become a Top 1% Dev with a Top End Devs Membership Links The article about .NET tools The C4 model for visualising software architecture Improve your .NET code quality with NDepend SharpLab try.dot.net GitHub: DiyazY Picks Diyaz - CLR via C#, 4th Edition | Microsoft Press Store Shawn - Lost something? Search through 91.7 million files from the '80s, '90s, and 2000s Wai- Watch BLOCKBUSTER | Netflix Official Site

Kat Marchán was the maintainer of NPM CLI for 5 years but now works at Microsoft on the VisualStudio product. Kat is passionate about Rust and uses Elixir and Phoenix to build a new Banchan Art site to serve artists. It helps connect artists with clients who want to commission custom artwork. The goal is to create a platform that does not exploit artists like many of the existing options. Amazingly, the Banchan Art Elixir project is OpenSource as well! Show Notes online - http://podcast.thinkingelixir.com/119 (http://podcast.thinkingelixir.com/119) Elixir Community News - https://twitter.com/elixirphoenix/status/1572934094098694145 (https://twitter.com/elixirphoenix/status/1572934094098694145) – Phoenix LiveView v0.18 was released! - https://phoenixframework.org/blog/phoenix-liveview-0.18-released (https://phoenixframework.org/blog/phoenix-liveview-0.18-released) – LiveView release blog post - https://github.com/phoenixframework/phoenixliveview/blob/v0.18.0/CHANGELOG.md (https://github.com/phoenixframework/phoenix_live_view/blob/v0.18.0/CHANGELOG.md) – LiveView changelog - https://www.youtube.com/watch?v=9-rqBLjr5Eo (https://www.youtube.com/watch?v=9-rqBLjr5Eo) – Chris McCord's ElixirConf keynote talking about the release - https://docs.google.com/forms/d/e/1FAIpQLSckJPn7n-k-vorjpQLTKtOlo4pxKYP64J71yg5iutTeY9jG5w/viewform (https://docs.google.com/forms/d/e/1FAIpQLSckJPn7n-k-vorjpQLTKtOlo4pxKYP64J71yg5iutTeY9jG5w/viewform) – Code Smells online survey - https://github.com/lucasvegi/Elixir-Code-Smells (https://github.com/lucasvegi/Elixir-Code-Smells) – Previous Elixir Code Smells github repository - https://ti.to/strange-loop/2023 (https://ti.to/strange-loop/2023) – Strange Loop's final conference held in Saint Louis, MO. Sept 21-22 in 2023 - Elixir 1.14 hidden date/time gem Do you have some Elixir news to share? Tell us at @ThinkingElixir (https://twitter.com/ThinkingElixir) or email at show@thinkingelixir.com (mailto:show@thinkingelixir.com) Discussion Resources - https://www.npmjs.com/ (https://www.npmjs.com/) - https://docs.npmjs.com/cli/v6 (https://docs.npmjs.com/cli/v6) - https://visualstudio.microsoft.com/vs/ (https://visualstudio.microsoft.com/vs/) - https://www.erlang.org/ (https://www.erlang.org/) - https://elixir-lang.org/ (https://elixir-lang.org/) - https://www.rust-lang.org/ (https://www.rust-lang.org/) - https://banchan.art/beta (https://banchan.art/beta) – Banchan Art site - https://github.com/BanchanArt/banchan (https://github.com/BanchanArt/banchan) – Banchan Art Elixir project Guest Information - https://twitter.com/zkat__ (https://twitter.com/zkat__) – Kat on Twitter - https://twitter.com/BanchanArt (https://twitter.com/BanchanArt) – BanchanArt on Twitter - https://github.com/zkat/ (https://github.com/zkat/) – on Github - https://banchan.art/beta (https://banchan.art/beta) – BanchanArt site - https://github.com/BanchanArt/banchan (https://github.com/BanchanArt/banchan) – Banchan Art Elixir Project Find us online - Message the show - @ThinkingElixir (https://twitter.com/ThinkingElixir) - Email the show - show@thinkingelixir.com (mailto:show@thinkingelixir.com) - Mark Ericksen - @brainlid (https://twitter.com/brainlid) - David Bernheisel - @bernheisel (https://twitter.com/bernheisel) - Cade Ward - @cadebward (https://twitter.com/cadebward)

Neste episódio conversamos com Lucas Vegi, professor da UFV e doutorando na UFMG, e com Marco Tulio Valente, professor da UFMG, sobre o artigo Code Smells in Elixir: Early Results from a Grey Literature Review https://homepages.dcc.ufmg.br/~mtov/pub/2022-icpc-era.pdf. Links: Repositório Elixir Code Smells https://github.com/lucasvegi/Elixir-Code-Smells. Vídeo: https://www.youtube.com/watch?v=3X2gxg13tXo Livro "Engenharia de Software Moderna" https://engsoftmoderna.info/ Code smells com Marcelo Maia no Fronteiras da Engenharia de Software: Parte 1 https://anchor.fm/fronteirases/episodes/4--Code-smells-com-Marcelo-Maia-UFU---Parte-1-ejkpqr e Parte 2 https://anchor.fm/fronteirases/episodes/4--Code-smells-com-Marcelo-Maia-UFU---Parte-2-ekctv0 Vídeo sobre Code Smells em Elixir https://youtu.be/zCzpgawEIns A Livebook notebook for Elixir Code Smells https://youtu.be/pV6YxGPvx4U Elixir Patterns https://elixirforum.com/t/elixir-patterns-self-published-handbook/46649 Elixir Forum https://elixirforum.com/t/code-smells-in-elixir-early-results-from-a-grey-literature-review/46676 Episódio com Marco Tulio https://anchor.fm/fronteirases/episodes/9--Ensino-de-Engenharia-de-Software-com-Marco-Tulio-Valente-UFMG-eqbqoh https://codestool.coding-gnome.com/courses/elixir-for-programmers-2 https://www.oreilly.com/library/view/designing-for-scalability/9781449361556/ Fio https://twitter.com/adolfont/status/1504860202868346890 A systematic literature review on bad smells — 5 W's: which, when, what, who, where http://doi.org/10.1109/tse.2018.2880977 Nosso site é https://elixiremfoco.com. Nosso canal no YouTube é https://www.youtube.com/c/ElixirEmFoco Estamos no Twitter em @elixiremfoco https://twitter.com/elixiremfoco. Nosso email é elixiremfoco@gmail.com. --- Send in a voice message: https://anchor.fm/elixiremfoco/message

Neste episódio, conversamos com Maurício F. Aniche,  professor na Universidade Tecnológica de Delft (TU Delft). O tema foi Aprendizado de Máquina em Engenharia de Software. A página do Maurício é https://www.mauricioaniche.com/. Ele está no Twitter como @mauricioaniche. Artigos mencionados: Jeroen Castelein, Maurício Finavaro Aniche, Mozhan Soltani, Annibale Panichella, Arie van Deursen: Search-based test data generation for SQL queries. ICSE 2018. Ludewig, M., Mauro, N., Latifi, S. and Jannach, D.: "Performance Comparison of Neural and Non-Neural Approaches to Session-based Recommendation". In: Proceedings of the 2019 ACM Conference on Recommender Systems (RecSys 2019). Copenhagen, 2019 Henk Grent, Aleksei Akimov, Maurício Aniche: Automatically Identifying Parameter Constraints in Complex Web APIs: A Case Study at Adyen. ICSE (SEIP) 2021. Casper Schröder, Adriaan van der Feltz, Annibale Panichella, Maurício Aniche: Search-Based Software Re-Modularization: A Case Study at Adyen. ICSE (SEIP) 2021. Jeanderson Cândido, Jan Haesen, Maurício Aniche, Arie van Deursen: An Exploratory Study of Log Placement Recommendation in an Enterprise System. MSR 2021: 143-154 Bart van Oort, Luis Cruz, Maurício Aniche, Arie van Deursen: The Prevalence of Code Smells in Machine Learning projects. WAIN@ICSE 2021 Mauricio Finavaro Aniche, Gabriele Bavota, Christoph Treude, Marco Aurélio Gerosa, Arie van Deursen: Code smells for Model-View-Controller architectures. Empir. Softw. Eng. 23(4): 2121-2157 (2018) Maurício Aniche, Frank Mulder, Felienne Hermans: Grading 600+ Students: A Case Study on Peer and Self Grading. ICSE (SEET) 2021: 211-220 Nossa equipe é formada por: Leonardo Fernandes (IFAL) Gustavo Pinto (UFPA) Fabio Petrillo (UQAC) Danilo Monteiro (Zup Innovation) Adolfo Gustavo Serra Seca Neto (UTFPR) - co-host deste episódio Ingrid Nunes (UFRGS) - co-host deste episódio Nosso site é https://fronteirases.github.io/. A edição deste episódio foi feita pela Zup Innovation. --- Send in a voice message: https://podcasters.spotify.com/pod/show/fronteirases/message

Você já olhou para um código que parecia errado, mas não soube dizer de imediato o porquê. Pode ser que você tenha se deparado com um Code Smell.

Il Design del software è una questione di compromessi: non esiste il design perfetto, c'è sempre un compromesso che è stato preso da qualche parte. Imparare i Code Smells è fondamentale per un motivo: i compromessi di cui parlavo si manifestano proprio negli smells, per cui saperli riconoscere è fondamentale per far si che questi compromessi diventino consapevoli e quindi controllati.Video su tutti i code smells sul mio canale Youtube: https://youtu.be/xTconoY_VWQ Articolo di Martin Fowler: https://martinfowler.com/bliki/CodeSmell.htmlRefactoring Guru descrizione Code Smells: https://refactoring.guru/refactoring/smells_____________________________________________________________________Seguimi anche su Youtube: https://www.youtube.com/channel/UCow5aybmZhzR7HbPf8JmcmAIl mio sito personale: https://www.dan-the-dev.it Il mio profilo LinkedIn: http://linkedin.com/in/daniele-scillia/ Il mio profilo Twitter: https://twitter.com/danielescilliaIl mio profilo GitHub: https://github.com/dan-the-dev/Per contattarmi: daniele.scillia@gmail.com (sono disponibile per collaborazioni, progetti, eventi, conferenze, corsi, coaching, mentoring).

Na entrevista de hoje falamos com Marcelo Maia, que é professor titular da UFU. Marcelo tem ampla experiência em engenharia de software, tanto que a nossa conversa sobre code smells rendeu tanto que dividimos em duas partes. Nessa primeira parte, falamos sobre o que é um code smell, como identificar, e se é possível priorizar. Na segunda parte falamos sobre como remover, sobre o status atual das ferramentas de identificação de smells (eles funcionam?), se code smells podem gerar bugs, além de trabalho de pesquisa que Marcelo conduziu com seu aluno de doutorado para responder perguntas sobre a variedade, principais achados e desafios da área de smells de código. Esta é a parte 2. Escute a parte 1 em https://anchor.fm/fronteirases/episodes/4--Code-smells-com-Marcelo-Maia-UFU---Parte-1-ejkpqr Interessou-se? Escute o podcast e nos avise o que achou pelas redes sociais! Revisão da Literatura sobre sobre code smells PAULO SOBRINHO, E. V. ; DE LUCIA, A. ; MAIA, M.A. A systematic literature review on bad smells - 5 W's: which, when, what, who, where. Sites do marcelo https://dblp.uni-trier.de/pid/97/4668.html http://www.portal.facom.ufu.br/pessoas/docentes/marcelo-de-almeida-maia http://lascam.facom.ufu.br/cms/ https://scholar.google.com/citations?user=AkhgR1AAAAAJ&hl=en http://lattes.cnpq.br/4915659948263445 http://isel.ufu.br --- Send in a voice message: https://podcasters.spotify.com/pod/show/fronteirases/message

Na entrevista de hoje falamos com Marcelo Maia, que é professor titular da UFU. Marcelo tem ampla experiência em engenharia de software, tanto que a nossa conversa sobre code smells rendeu tanto que dividimos em duas partes. Nessa primeira parte, falamos sobre o que é um code smell, como identificar, e se é possível priorizar. Na segunda parte falamos sobre como remover, sobre o status atual das ferramentas de identificação de smells (eles funcionam?), se code smells podem gerar bugs, além de trabalho de pesquisa que Marcelo conduziu com seu aluno de doutorado para responder perguntas sobre a variedade, principais achados e desafios da área de smells de código. Interessou-se? Escute o podcast e nos avise o que achou pelas redes sociais! Revisão da Literatura sobre sobre code smells PAULO SOBRINHO, E. V. ; DE LUCIA, A. ; MAIA, M.A. A systematic literature review on bad smells - 5 W's: which, when, what, who, where. Sites do marcelo https://dblp.uni-trier.de/pid/97/4668.html http://www.portal.facom.ufu.br/pessoas/docentes/marcelo-de-almeida-maia http://lascam.facom.ufu.br/cms/ https://scholar.google.com/citations?user=AkhgR1AAAAAJ&hl=en http://lattes.cnpq.br/4915659948263445 http://isel.ufu.br --- Send in a voice message: https://podcasters.spotify.com/pod/show/fronteirases/message

Als Entwickler will man ja versuchen Bugs in seinem Code zu vermeiden, es gibt aber auch gewisse Indizien die später zu einem Bug führen können, sogenannte Code smells. In dieser Episode liste ich einige auf und helfe dir damit weitere Bugs zu vermeiden. *** Video Version *** https://youtu.be/AZdzY42YwVA *** Links zum Video *** https://de.wikipedia.org/wiki/Code-Smell Lade mich auf ein Kaffee ein: https://www.paypal.me/BlackScorp --- This episode is sponsored by · Anchor: The easiest way to make a podcast. https://anchor.fm/app

Um Code Smells und ihre Behebung mittels Refactorings geht es in der einhundertsiebenundvierzigsten Episode des Anwendungsentwickler-Podcasts. Inhalt Was ist ein Code Smell? Smells sind Indikatoren für Code, der überarbeitungswürdig ist. Man erkennt sie anhand verschiedener Muster (z.B. lange Methoden). Die Smells können mit Refactorings überarbeitet und (hoffentlich) eliminiert werden. Nicht alle Smells sind immer schlecht.... Der Beitrag Code Smells und Refactorings – Anwendungsentwickler-Podcast #147 erschien zuerst auf IT-Berufe-Podcast.

In this episode, we discuss code smells. These are signs that your computer program might need some changes as it is producing a bad odor. https://sourcemaking.com/refactoring/smells https://blog.codinghorror.com/code-smells/ --- Support this podcast: https://anchor.fm/tom-henricksen/support

Podczas pracy nad rozwojem oprogramowania dostrzegamy pewne rozwiązania, które są jasnym sygnałem do podjęcia się refaktoryzacji danego fragmentu kodu. Kenta Beck zdefiniował termin Code Smells – to cechy kodu, które świadczą o złej implementacji, utrudniającej utrzymanie oraz rozwój kodu.Na jakie Code Smells zwracać uwagę w swoim kodzie?W tym odcinku podcastu skupiamy się na Code Smells, które z naszej perspektywy pojawiają się najczęściej i nad którymi warto popracować.Jeżeli chcesz poznać więcej potencjalnych smrodków w kodzie serdecznie polecamy z zapoznaniem się z materiałem umieszczonym w serwisie Refactoring.Guru.Zapraszam do odsłuchu ⤵️⤵️

Podczas pracy nad rozwojem oprogramowania dostrzegamy pewne rozwiązania, które są jasnym sygnałem do podjęcia się refaktoryzacji danego fragmentu kodu. Kenta Beck zdefiniował termin Code Smells – to cechy kodu, które świadczą o złej implementacji, utrudniającej utrzymanie oraz rozwój kodu.Na jakie Code Smells zwracać uwagę w swoim kodzie?W tym odcinku podcastu skupiamy się na Code Smells, które z naszej perspektywy pojawiają się najczęściej i nad którymi warto popracować.Jeżeli chcesz poznać więcej potencjalnych smrodków w kodzie serdecznie polecamy z zapoznaniem się z materiałem umieszczonym w serwisie Refactoring.Guru.Zapraszam do odsłuchu ⤵️⤵️

Why Immutability is Desirable This week's tip is on the topic of immutability, and why it's often considered a good thing for your data structures. I'll share my thoughts on the topic in a moment, but first a quick note from this week's sponsor. Sponsor - devBetter Group Career Coaching for Developers If you're not advancing as quickly in your career as you'd like, you may find value in joining a semi-formal career and technical coaching program like devBetter.com. I launched devBetter a few months ago and so far we have a small group of motivated developers meeting every week or two. I answer questions, review code, suggest areas in which to improve, and occasionally assign homework. Interested? Learn more at devBetter.com. Show Notes / Transcript Let's talk about immutability. This topic is on my mind because I just wrote an article about getting language support for immutability and, more broadly, DDD value objects, in C#. Value objects area DDD pattern, and one of their defining characteristics is that they're immutable. I keep using that word, so I should probably define it. An immutable data structure (an object in C#) is one that, once created, cannot have its state modified. I mention wanting language support for this feature in C# - that's not to imply that you can't create immutable objects today. It's just a lot of manual work, and easy to get wrong or screw up in the future because nothing enforces immutability at the class level. Typically in C# to create an immutable object you create a class with properties that lack setters, and then you assign values to these properties in the class constructor. Short of some reflection trickery, instances of this type cannot have their properties modified once they've been instantiated. Why might we want this? The biggest advantage I get from immutability in objects is knowledge that instances of these types are always in a valid state. That means any method using such types doesn't have to waste effort trying to verify they're in a valid state. Here's a common example. Imagine your system needs to work with date ranges that include a start and end date. You might have many methods that take in two DateTime types, and in these methods you always expect the end date to be later than the start date. So, being a good programmer, you write a guard clause to ensure start date precedes end date. This logic ends up scattered all over the place, and maybe sometimes you forget or don't bother with it, so not it's not even enforced consistently, allowing bugs to creep in. What if instead you created an immutable DateRange class, passed the start and end dates into its constructor, and ensured they were valid there? If not, you'd throw an appropriate exception. Now, any method that was accepting a start and end date can just take in a DateRange instead, shortening these methods' parameter lists. And they can remove all of their validation on start date and end date because that's now done in the DateRange class. Why can you trust that it was done? Because of immutability. If it was valid when it was created, it must still be valid now since it couldn't be changed in the meantime. Your validation logic only has to be performed in one place, and immutability gives you guarantees that it will be applied so you don't have to defensively code for it everywhere. Another advantage immutability offers is thread safety. You don't have to worry about race conditions or synchronization issues between different threads when they work with immutable objects. Why not? Simply because the objects can't change. Operating on immutable objects may produce new instances of objects, but this typically doesn't pose an issue for multi-threaded applications. The issue is more commonly something like an instance that two threads are referencing, and each thread tells the instance to increment a counter at the same time. The end result may be unexpected due to how the calculation may be completed. This is typically overcome through the use of locks, but you can pass around immutable objects between threads all you want and never have to worry about this issue. Have you ever passed an object to a method, and then found yourself surprised when the method modified the object? I generally dislike this kind of thing, and C# even has a new keyword in that will ensure this doesn't happen. I'll link to more on the in keyword in the show notes, but it has some restrictions and hasn't seen widespread adoption, yet. Another way to ensure that the state of an instance you pass to a method isn't modified within that method is to use an immutable object. This makes it much easier to reason about and debug your code, and can have performance benefits since objects that won't be modified can always be passed by reference, without copying them to the stack. Immutable types are much easier to test than other types, and for this as well as the above reasons using them appropriately can lead to better, more maintainable code. Eliminate the primitive obsession code smell, better encapsulate concepts that tie together several values, and force validation (and other business rules) to live with these values instead of in the types that use them. You should find over time that your domain model becomes much cleaner as a result. Show Resources and Links devBetter 5 Benefits of Immutable Objects Guard Clauses The C# in parameter modifier Refactoring and Code Smells

I've talked quite a bit about code smells over the course of my career. My Refactoring Fundamentals and Azure Refactoring courses on Pluralsight both discuss the topic, with the former going into great depth and covering literally dozens of code smells. The course is over 8 hours long, but it not only demonstrates tons of code smells but also shows how to refactor to improve your code in response to them. It's important to note that code smells represent things in your code that are potentially bad. They should catch your attention, and you should think about whether, in context, the smell in question is acceptable or not. Sometimes, it's perfectly fine, or it's not worth the effort to refactor to a different design. If you've never heard of the term code smell, I encourage you to look into it. There are some links in the show notes for this episode. One benefit of learning about code smells mirrors a benefit of learning about design patterns, which is that these named smells allow you to identify and communicate concepts quickly with other developers. For example, if you're discussing some code and mention it seems to have 'primitive obsession', that term refers to a specific code smell which is well-documented and which has certain known refactoring approaches. By using this term, you convey a lot of information in just two words that otherwise might have required a great deal more explanation. It can be useful as well to learn about different categories of code smells. These categories include things like Bloaters, Obfuscators, and Couplers, as well as smells specific to kinds of code, like testing smells. These categories help as you're learning about code smells because they let you see a variety of smells that all have similar impacts on the code. Bloaters tend to result in code becoming larger than necessary. Couplers introduce unnecessary coupling into the application. Obfuscators make it more difficult to quickly understand how some part of your application works. And test smells make tests more difficult to write and maintain, or less reliable when run. Some code smells you can identify with static code analysis tools, like NDepend. For instance, you can easily write a query in NDepend to return all methods over a certain number of lines of code. These kinds of tools can help you identify potential problem areas in your code so you can better direct your refactoring efforts. I may dive into some different code smells, and how to correct them, in future tips. In the meantime, if you want to get up to speed the best resource I can recommend is my Refactoring Fundamentals course, on Pluralsight. Show Resources and Links Refactoring Fundamentals Azure Developer: Refactoring Code Code Smells Refactoring Book (classic 1999) Refactoring Book (2nd Ed.) (Available 31 Dec 2018)

Most developers are of the opinion that CSS is nasty to deal with. And it can be, especially when you treat it as a second-class citizen and don't take advantage of tools that are designed to help with the process. CSS in many development shops is being managed with the same sort of sophistication that could be expected of javascript a decade ago and we can do better. Read more › The post CSS Code Smells appeared first on Complete Developer Podcast.

Doc Norton talks about the experimentation mindset. This episode is sponsored by Smartsheet. Show Notes: Slides from Doc’s presentation on the experimentation mindset XP = eXtreme Programming Other methodologies that fall into the "agile" category: Scrum, Lean Kent Beck, Ron Jeffries, and Ward Cunningham were all mentioned. They are all signers of the Agile Manifesto. Chris Argyris was mentioned in regards to single-loop and double-loop learning Book: Escape Velocity by Doc Norton - it has increased in price since the recording. It will now set you back at least 5 entire dollars. Supplemental links from Doc: CTO2 DocOnDev Collaboration Contracts Refactoring Code Smells Video: Experimentation Mindset Mob Programming Learning through experimentation PDF: How Organizations Learn From Harvard Business Review: Collective Genius Argyris: Teaching Smart People how to Learn (and PDF version) A/B Testing and the Experimentation Culture Enlightened Experimentation Smart Business Experiments Evidence Based Management link:http://www.edbatista.com/2008/05/double-loop.html[Ed Batista blog post on double-loop learning Lean Change Book: Scaling Up Excellence Experiential Learning Doc Norton is on Twitter. Want to be on the next episode? You can! All you need is the willingness to talk about something technical. Music is by Joe Ferg, check out more music on JoeFerg.com!

This week we're going to get very practical. Today we're talking about identifying code smells (very common ones) and a few ways to fix them.

Добрый день уважаемые слушатели. Представляем новый выпуск подкаста RWpod. В этом выпуске: Ruby Ruby Versions Used in Commercial Projects in 2017, Docker + Rails + System tests with Headless Chrome и Functional Programming Aspects of the Ruby Language How we switched from Sprockets to Webpack, Partition and conquer и 80% Smaller Rails Page Size With Rack Deflate Dckerize - supercharged Rails development using Docker, WebSocket Director - command line tool for testing websocket servers using scenarios, Passwordless - add authentication to your Rails app without all the icky-ness of passwords и Speeding Up Tests JavaScript All You Need To Know About CSS-in-JS, Right-To-Left Development In Mobile Design и CSS Code Smells Proper Error Handling in JavaScript, How we do Vue: one year later и Node.js Best Practices YamUI - an UI component framework for Yammer.com, Emergence.js - a lightweight, high-performance JS plugin for detecting and manipulating elements in the browser и JSON5 - a proposed extension to JSON that aims to make it easier for humans to write and maintain by hand В гостях - Павел Калашников Блог Github Twitter Conferences RUBY Meditation #19

The idea of code smells is they are patterns or anti-patterns that are easy to identify and show the code needs to be reviewed in that area when refactoring your code. Research by Tufano et al. found that there is empirical evidence for the consequences of "technical debt" but only anecdotal evidence as to how, when, or why this occurs. Read more › The post Code Smells Part 2 appeared first on Complete Developer Podcast.

The idea of code smells is they are patterns or anti-patterns that are easy to identify and show the code needs to be reviewed in that area when refactoring your code. Read more › The post Code Smells Part 1 appeared first on Complete Developer Podcast.

Добрый день уважаемые слушатели. Представляем новый выпуск подкаста RWpod. В этом выпуске: Ruby Rails 5.1.0.beta1, 15 Weird Things About Ruby That You Should Know и Ruby reject! Using PhantomJS to Capture Analytics for a Rails Email Template, Lessons learned and Code Smells detected with Reek, Objects as Ruby Hash Keys и Creating Powerful Command Line Tools in Ruby KMS - simple and powerful Ruby on Rails CMS for developers, Brains - Feedforward neural network toolkit for JRuby и Working with Internationalization (video) JavaScript HTTP/2 – A Real-World Performance Test and Analysis, Getting started with variable fonts и Won WebAssembly logo contest Babel-preset-env: a preset that configures Babel for you, Why Learn Functional Programming in JavaScript? и Code review checklist Propeller - a front-end responsive framework based on Google's Material Design Standards & Bootstrap, AR.js - Efficient Augmented Reality for the Web using ARToolKit, Trello Clone и HTML5 Robot Conferences Ruby Meditation #14 Elixir Club 6

Felienne is always learning. In exploring her PhD dissertation and her public speaking experience it's clear that she has no intent on stopping! Most recently she's been exploring a large corpus of Scratch programs looking for Code Smells. How do children learn how to code, and when they do, does their code "smell?" Is there something we can do when teaching to promote cleaner, more maintainable code?

Digging deeper on smart pointers and mutability with Cell and RefCell. Notes What are the Cell and RefCell types, and when should we use them? Today, we follow up both the detailed discussion of smart pointers in e015 and the closely related discussion in Interview 2 with Raph Levien, and look at two types you need to have a good idea how to deal with if you want to use these smart pointer types more ergonomically—that is, how to use them without feeling like you’re beating your head against a wall! Links Rust 1.10 blog post full release notes cdylib RFC: text | discussion implementation rustup 0.3.0 release Integer32 (Carol Nichols’ and Jake Goulding’s new Rust consultancy) announcement blog post reddit discussion IntelliJ Rust reddit discussion Tango: source | talk Cell and RefCell: Cell Types in The Rust Programming Language Standard library: std::cell module docs (detailed explanation, complementary to the book) Cell docs (at std::cell::Cell) RefCell docs (at stc::cell::RefCell) Sponsors Aleksey Pirogov Chris Palmer Daniel Collin Derek Morr Doug Reeves Eric Fulmer Hamza Sheikh Jakub “Limeth” Hlusička Keith Gray Lachlan Collins Leif Arne Storset Luca Schmid Micael Bergeron Michael Clayton Pascal Hertleif Ralph Giles (“rillian”) Ralph “FriarTech” Loizzo Raph Levien reddraggone9 Ryan Ollos Vesa Kaihlavirta William Roe (Thanks to the couple people donating who opted out of the reward tier, as well. You know who you are!) Become a sponsor Patreon Venmo Dwolla Cash.me Flattr PayPal.me Contact New Rustacean: Twitter: @newrustacean Email: hello@newrustacean.com Chris Krycho GitHub: chriskrycho Twitter: @chriskrycho

Check out JS Remote Conf!   02:22 - Elijah Manor Introduction Twitter GitHub Blog LeanKit Eliminate JavaScript Code Smells (Elijah's Talk Abstract) A video containing the 30 min version of the talk: Eliminate JavaScript Code Smells The full slides (60 mins worth of material) 04:49 - What is a “Code Smell”? Martin Fowler: CodeSmell ESLint JSHint 10:21 - Copy/Paste Code Error jsinspect and jscpd ES6, ES7, Babel Support 13:11 - Using ES6 to Eliminate Code Smells 15:48 - Refactoring Case Statements The Strategy Pattern 21:29 - Juniors and Code Smells Code Reviews 27:29 - Isomorphic Code 31:12 - Framework Code Smells 33:47 - Identifying New Code Smells 36:33 - When Code Smells are OK 39:10 - Why use parameters? Picks Terms And Conditions May Apply (AJ) Nodevember (Aimee) Developer Tea (Aimee) Jake Shimabukuro (Joe) Screeps (Joe) react-styleguide-generator (Elijah) react-styleguidist (Elijah) The Phantom Menace - What it Should Have Been (AJ) Attack of the Clones - What it Should Have Been (AJ)

Check out JS Remote Conf!   02:22 - Elijah Manor Introduction Twitter GitHub Blog LeanKit Eliminate JavaScript Code Smells (Elijah's Talk Abstract) A video containing the 30 min version of the talk: Eliminate JavaScript Code Smells The full slides (60 mins worth of material) 04:49 - What is a “Code Smell”? Martin Fowler: CodeSmell ESLint JSHint 10:21 - Copy/Paste Code Error jsinspect and jscpd ES6, ES7, Babel Support 13:11 - Using ES6 to Eliminate Code Smells 15:48 - Refactoring Case Statements The Strategy Pattern 21:29 - Juniors and Code Smells Code Reviews 27:29 - Isomorphic Code 31:12 - Framework Code Smells 33:47 - Identifying New Code Smells 36:33 - When Code Smells are OK 39:10 - Why use parameters? Picks Terms And Conditions May Apply (AJ) Nodevember (Aimee) Developer Tea (Aimee) Jake Shimabukuro (Joe) Screeps (Joe) react-styleguide-generator (Elijah) react-styleguidist (Elijah) The Phantom Menace - What it Should Have Been (AJ) Attack of the Clones - What it Should Have Been (AJ)

Check out JS Remote Conf!   02:22 - Elijah Manor Introduction Twitter GitHub Blog LeanKit Eliminate JavaScript Code Smells (Elijah's Talk Abstract) A video containing the 30 min version of the talk: Eliminate JavaScript Code Smells The full slides (60 mins worth of material) 04:49 - What is a “Code Smell”? Martin Fowler: CodeSmell ESLint JSHint 10:21 - Copy/Paste Code Error jsinspect and jscpd ES6, ES7, Babel Support 13:11 - Using ES6 to Eliminate Code Smells 15:48 - Refactoring Case Statements The Strategy Pattern 21:29 - Juniors and Code Smells Code Reviews 27:29 - Isomorphic Code 31:12 - Framework Code Smells 33:47 - Identifying New Code Smells 36:33 - When Code Smells are OK 39:10 - Why use parameters? Picks Terms And Conditions May Apply (AJ) Nodevember (Aimee) Developer Tea (Aimee) Jake Shimabukuro (Joe) Screeps (Joe) react-styleguide-generator (Elijah) react-styleguidist (Elijah) The Phantom Menace - What it Should Have Been (AJ) Attack of the Clones - What it Should Have Been (AJ)