70 episódios

On Elixir Wizards, we talk with software developers from around the world about the Elixir language and other modern web technologies. In season four our theme is System and Application Architecture.
Elixir Wizards is hosted by Justus Eapen and Eric Oestrich of SmartLogic, a dev shop that’s been building custom software since 2005 and running Elixir applications in production since 2015.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)

Elixir Wizards SmartLogic LLC

    • Tecnologia

On Elixir Wizards, we talk with software developers from around the world about the Elixir language and other modern web technologies. In season four our theme is System and Application Architecture.
Elixir Wizards is hosted by Justus Eapen and Eric Oestrich of SmartLogic, a dev shop that’s been building custom software since 2005 and running Elixir applications in production since 2015.
Learn more about how SmartLogic uses Phoenix and Elixir. (https://smartlogic.io/phoenix-and-elixir?utm_source=podcast)

    Eric Steen on Neuroevolution in AI

    Eric Steen on Neuroevolution in AI

    Building a sophisticated AI that can evolve to fit our vast and diverse needs is a Herculean challenge. Today we speak with senior engineer Eric Steen about Automata, his experimental Elixir project that uses neuroevolution and cutting edge theory to create a multi-agent behavior tree — or really good AI in the common tongue. But before we tap into that rich topic, we talk with Eric about tech burnout, his background, and why Elixir is an excellent language for writing modern software. He then unpacks AI concepts like the need to develop backpropagation in your system, and the value of “neural diversity,” and Markov decision processes.


    After Eric gives his take on architecture versus design and the place of domain-driven design, we discuss Automata. A key breakthrough, Eric shares his enthusiasm for ‘novelty search,’ where machines learn from a variety of new behaviors and searches, as opposed to completing one task at a time. We touch on Automata’s progress, Eric’s long-term approach, and what his project might be used for. Near the end of our interview, we chat about CryptoWise, a collaborative analysis platform for cryptocurrency.


    Todd Resudek then opens with another edition of Pattern Matching, where he interviews Whatsapp engineer Michał Muskała. They talk about Michał’s career, the movies and music that he enjoys, and the projects that excite him. Tune in to hear more about both Michał and neuroevolution in AI.


    Key Points From This Episode:



    Experiencing tech burnout and challenges around algorithms rendering you redundant.
    Hear about Eric’s programming background and shifts in the industry.
    Backpropagation and using Elixir to build a neural evolutionary system.
    How Markov decision processes help systems choose between possible actions.
    Eric’s take on architecture versus design and the place of domain-driven design.
    Exploring Automata — Eric’s ambitious multi-agent behavior tree.
    The importance of neurodiversity when building AIs; they need to adapt to many needs.
    Novelty search; why learn through one task when you can learn through a variety of tasks at the same time?
    Automata’s practical applications and why Eric sees it as a long-term project.
    Eric shares a progress report on his work and using design processes like Sprint.
    What Eric would like people to use Automata for.
    A sense that Elixir is gaining in popularity within Silicon Valley.
    Eric gives an elevator-pitch for CryptoWise, a collaborative analysis platform for cryptocurrency.
    Todd Resudek interviews Michał Muskała on another edition of Pattern Matching.
    Michał shares his background and his move from Poland to London.
    Movies and music that Michał enjoys, and details on projects that excite him.
    Differences between Erlang and Elixir and why both communities would benefit from working together.


    Links Mentioned in Today’s Episode:


    SmartLogic — https://smartlogic.io/
    Eric Steen on LinkedIn — https://www.linkedin.com/in/ericsteen1/
    Eric Steen — https://twitter.com/the_steener
    Webflow — https://webflow.com/
    Automata GitHub — https://github.com/upstarter/automata
    Automata on Slack — https://join.slack.com/t/automata-project/shared_invite/zt-e4fqrmo4-7ujuZwzXHNCGVrZb1aVmA
    CryptoWise — https://www.cryptowise.ai/
    Hippo Insurance — https://www.hippo.com/
    Carl Hewitt — https://en.wikipedia.org/wiki/Carl_Hewitt
    Stanford University — https://www.stanford.edu/
    MIT — https://web.mit.edu/
    Actor Model — https://en.wikipedia.org/wiki/Actor_model
    Marvin Minsky — http://web.media.mit.edu/~minsky/
    Tensorflex on GitHub— https://github.com/anshuman23/tensorflex
    Matrex on GitHub — https://github.com/versilov/matrex
    Handbook of Neuroevolution Through Erlang —
    https://www.springer.com/gp/book/9781461444626
    Markov Decision Process — https://en.wikipedia.org/wiki/Markov_decision_process
    Amazon W

    • 49 min
    Johnny Winn on Kitchen Secrets and Beautiful Coding

    Johnny Winn on Kitchen Secrets and Beautiful Coding

    No one cares about clever code. Instead, people want code that works. Code that they can read six months down the line. Today we speak with Johnny Winn, who avoids writing clever code by following a clear vision — “Make it work, then make it beautiful, then if you really, really have to, make it fast.”


    A Renaissance man, Johnny’s career ranged from cheffing to design before he settled into software engineering. Reflecting his many interests, we spend the first section of the podcast chatting about cooking. Johnny shares his kitchen secrets before seamlessly transitioning into the topic of coding. After touching on why clever code is bad code, we explore the trend of ‘componentizing,’ when your views are taken over by an endless array of components and folders. Like Johanna Larsson, a previous guest, Johnny makes a case for umbrella projects and explains why many of us have been using them incorrectly this whole time.


    An enemy of dogma, Johnny emphasizes that teams should use what works best for them, and not what conventional wisdom suggests. Following this, we dive into imposing patterns on our architecture bases, how design patterns serve as communication tools, and why tribal knowledge leads to communication issues. Johnny brings his experience to bear and shares how he structures projects while limiting component creation. Near the end of the episode, Johnny talks about how he learned the cardinal sins of coding before leaving us with his final hot take on living a balanced life. So, tune in for a dynamic conversation where Johnny is as likely to share his smoked pork recipe as he is to deliver key coding insights.


    Key Points From This Episode:



    Introducing Johnny Winn and why he’s been called a ‘Renaissance man.’
    How to cook the perfect steak or burger — don’t share this with anyone.
    Hear about what Johnny would cook if he needed to impress you.
    A recipe for the perfect smoked pork shoulder brine.
    Food wars; we debate what the best meat and sandwiches are.
    The inter-industry virtue of keeping things simple and why clever code is bad code.
    Exploring the trend of ‘componentizing’ everything to extreme levels.
    The case for umbrella projects and why most people are doing it wrong.
    Ignoring conventional wisdom and favoring approaches that best work for a team.
    Winging it versus adding too many components and nested file structures.
    How design patterns function as a way to communicate.
    Why developing tribal knowledge can lead to communication issues.
    Johnny’s mission when coding; “Make it work, make it beautiful, make it fast.”
    The method that Johnny uses to structure a project.
    Johnny’s advice for avoiding the cardinal sins of coding; write bad code in your side projects.
    The importance of living a balanced life and spending time with loved ones.


    Links Mentioned in Today’s Episode:


    SmartLogic — https://smartlogic.io/
    Johnny Winn on Twitter — https://twitter.com/johnny_rugger
    Johnny Winn on LinkedIn — https://www.linkedin.com/in/johnnywinn5/
    Elixir Fountain — https://twitter.com/elixirfountain?lang=en
    Code Sync — https://www.codesync.global/
    Code BEAM San Francisco — https://codesync.global/conferences/code-beam-sf/
    Kerrygold — https://www.kerrygoldusa.com/
    Kraft Macaroni & Cheese Deluxe — https://www.kraftmacandcheese.com/products/100166000004/deluxe
    Annie’s Mac and Cheese — https://www.annies.com/products/mac-and-cheese/
    Velveeta — https://www.myfoodandfamily.com/brands/velveeta
    Shake Shack — https://www.shakeshack.com/
    Dave Thomas — https://www.thoughtworks.com/profiles/dave-thomas
    Phoenix — https://www.phoenixframework.org/
    Chris McCord — http://chrismccord.com/
    Johanna Larsson — https://blog.jola.dev/
    Johanna Larsson Episode — https://smartlogic.io/podcast/elixir-wizards/s4e11-larsson/
    The Pragmatic Bookshelf — https://pragprog.com

    • 50 min
    Miki Rezentes on how it's APIs All the Way Down

    Miki Rezentes on how it's APIs All the Way Down

    According to an ancient myth, the world rests on the back of a turtle. And what does that turtle stand on? Another turtle. It turns out that it’s turtles all the way down. Miki Rezentes, today’s guest, believes that all software rests on the back of APIs. Similar to the myth, it’s APIs all the way down. We open our conversation by discussing how homeschooling her children did more to prepare Miki for a software career than anything else she’s encountered. Miki shares highlights from her talk, ‘APIs All the Way Down’. This set up this episode’s key theme, that the tech industry is too concerned with how its software interacts to focus on how the people in its organizations communicate — their ‘human APIs.’ Following this, we ask Miki how she learns people’s APIs and we talk about the benefits of observation and mirroring. Tracking her career, we touch on how Miki transitioned from a homemaker to a developer before diving into her recent work at the data science platform Mode. She provides unique insights into how she views architecture and design and why the concept of domain-driven design doesn’t go far enough. We chat about how you can see your team as customers to promote domain-driven design and then drill into what she does to create a ‘shared pool of knowledge’ with her team. As Miki explains, ‘people problems’ are more difficult than technical ones and developers often make mistakes by not first developing common understanding. Especially when this relates to expectations within a company. Near the end of the episode, we explore what leaders can do to maintain productivity when growing their teams. Tune in to hear what you can do to deepen your team’s pool of understanding and improve the quality of your communication.


    Note: this episode was recorded in late July when Miki was working at Mode; she is now a Senior Software Engineer at Frame.io.


    Key Points From This Episode:



    Why homeschooling her kids better prepared Miki for software development than anything else.
    How people within an organization express themselves through individual APIs.
    Understanding that people come from different backgrounds which influence their API.
    The ‘shared pool of knowledge’ and figuring out how to communicate with people.
    Miki’s journey from homemaker to becoming a software engineer.
    How nobody really knows what they’re doing.
    Security as a trade-off, privacy, and the power of two-factor authentication.
    Hear about Miki’s work at the data science platform Mode.
    What Miki enjoys most about working in Elixir and what she uses it for.
    How Miki sees architecture and the differences between architecture and design.
    Domain-driven design and the differences between data models and software.
    Treating your team ‘Agilely’ and seeing them as your customers.
    Miki’s process of developing a shared pool of understanding before hammering out the end-to-end components.
    Why ‘people problems’ are much more difficult than development problems.
    How tech companies misdiagnose ‘people problems’ as bad design.
    Conway’s Law and how code production reflects an organization’s structure.
    The importance of setting expectations to maintain productivity as a team grows in size.
    The danger of the Peter principle; when people are promoted to their level of incompetency.


    Links Mentioned in Today’s Episode:


    Miki Rezentes LinkedIn —https://www.linkedin.com/in/miki-rezentes-823ba02a/
    Miki Rezentes GitHub — https://github.com/mrezentes
    Miki Rezentes Twitter — https://twitter.com/mikirez
    Mode — https://mode.com/
    SmartLogic — https://smartlogic.io/
    Elixir Wizards Survey — smr.tl/podcastsurvey
    Manning Publications — https://www.manning.com/
    ‘APIs All the Way Down’ — https://www.youtube.com/watch?v=hBpbEsAG4es
    Turtles all the way down — https://en.wikipedia.org/wiki/Turtles_al

    • 42 min
    ElixirConf 2020 Preview

    ElixirConf 2020 Preview

    With ElixirConf 2020 just around the corner, today’s episode is a sneak peek where we talk with six of this year’s speakers. Each speaker gives listeners an elevator pitch of their talk while throwing in extra details about who their talk is aimed at, what they learned through the process, and which talks they’re excited about attending.


    Our first guest is Quinn Wilton, a developer at Tinfoil Security, whose talk is titled ‘Type-Safe LiveView with Gleam’. Quinn explains how she’s created a symbiosis between Elixir and Gleam that helps her create more consistent code while offsetting the disadvantages of dynamic typing.


    We then chat with Dan Lindeman whose talk, ‘Short Circuit IoT Development Time with Nerves,’ is an overview of building custom hardware using Nerves and Elixir.


    After Dan’s plug on how you can start programming Nerves on your laptop, we welcome Jeffrey Utter to the show. His talk is a deep dive into ‘Debugging Live Systems on the Beam.’ Teasing out the topic, we discuss inefficiencies in the debugging process and how many developers adopt a ‘whack-a-mole’ approach to dealing with bugs.


    From debugging to UintSet, Luciano Ramalho, our next speaker, gives us a taste of his presentation, ‘UIntSet: enumerable, streamable, understandable.’ Luciano shares how the Go language inspired him to experiment with leveraging protocols and streams to build new idiomatic Elixir data structures from scratch. He also touches on the importance of being humble when learning new languages and gearing Elixir to a non-engineer user base.


    After Luciano, we’re joined by Melvin Cedeno, a fellow Elixir Wizard from the SmartLogic family. Melvin brings his teaching experience to bear on the topic of ‘Teaching Functional Programming with Elixir.’ This is a key talk in growing our community, especially when considering the point that being an Elixir genius doesn’t necessarily mean that you’re well-suited to teach it.


    Last but certainly not least, we speak with Japa Swadia from Podium about her talk, ‘Domain-Driven Design with Elixir’ — a subject that’s been a huge focus on the podcast. We chat about what domain-driven design means and why it’s an important foundational concept for beginners to learn.


    Tune in for this tip-of-the-iceberg preview. It’s just a glimpse into the varied and wonderfully informative talks you can expect at ElixirConf 2020.


    Key Points From This Episode:



    Introducing Quinn Wilton who is using Gleam to interact with Elixir.
    How being acquired by Synopsys has given Tinfoil Security access to greater resources.
    Balancing the advantages of Elixir with its drawbacks when it comes to dynamic analysis.
    What Gleam is and how it makes static typing more approachable.
    Teasing Quinn’s ElixirConf talk — ‘Talk Type-Safe LiveView with Gleam’
    What Quinn has learned from the process of creating his presentation.
    Building a dissembler and the talk that Quinn is most looking forward to attending.
    Dan Lindeman’s work at Very making solar micro-grids.
    The benefits of Elixir and Nerves when building custom hardware.
    Who Dan’s talk is aimed at and why it’s appropriate for any experience level.
    Working with smart minds and laboring through hardware docs that often lie.
    How scary it can be to work with hardware and the value of having your talk appeal to entry-level Elixir users.
    Jeffrey Utter unpacks his talk — ‘Debugging Live Systems on the Beam.’
    How most people play ‘whack-a-mole’ when dealing with live system bugs.
    Using match specs to hone in on your debugging process.
    Why most Elixir coders should learn about Jeffrey’s debugging system.
    Why is Recon Library is such an excellent tool and its potential uses in distributed systems.
    Hear which talks Jeffrey is looking forward to attending.
    How Go inspired Luciano Ramalho to explor

    • 1h 17 min
    Mark Windholtz on Domain-Driven Design (DDD)

    Mark Windholtz on Domain-Driven Design (DDD)

    Domain-driven design and extreme programming can help bridge the gap between development and business, and today we invite Mark Windholtz from Agile DNA to talk about how! Mark starts out by telling us about his early work in extreme programming before agile was a term and how he switched from Rails to Elixir after realizing its power for implementing domain-driven design. We take a deep dive with him into what these concepts mean, hearing him weigh in on how DDD can help architecture accommodate both development and business oriented complexities. For Mark, development and business teams must get a better understanding of each other’s jargon, and DDD is a way to accomplish this. The goal is to find a way of building a solid software core and to move away from features to systems thinking, whereby flexible software can make it more possible to do agile on the business side. We chat about some of the practices and principles that come into play when implementing DDD for Mark, and he details concepts like ubiquitous language, bounded contexts, and how to focus on the core domain by exploring models using tactical and strategic patterns. Along with this, Mark discusses users not being a domain concept, the challenges of getting new terms to stick in teams’ minds, and the task of refactoring code to reflect updated glossaries. Near the end of our conversation, Mark drills down on how DDD can optimize team efficiency. In closing, we get to know Chris Bell from ElixirTalk a little better in this week’s edition of Pattern Matching with Todd!


    Key Points From This Episode:



    Thoughts on SpaceEx and their approach to engineering: system versus feature optimization.
    Mark’s background in extreme programming, how he got started with AgileDNA, and the work they do there.
    A definition of extreme programming that adds engineering practices to Scrum.
    Elixir’s superior ability to do DDD compared to Rails and how Mark got started using it.
    A brief introduction to domain-driven design, an approach to simplifying complex software.
    How architecture needs to accommodate essential as well as accidental complexity.
    Elixir’s ability to accommodate the building of domain models with well-separated code chunks.
    Principles of ubiquitous language and bounded contexts that make up DDD for Mark.
    Ubiquitous language helps devs and businesspeople understand each other.
    Bounded contexts: ‘Within this space, this world means this thing.’
    Shifting focus from trying to make not all software, but core software, good.
    What patterns are applied to use principles of ubiquitous language and bounded contexts.
    Finding and focusing on the core domain by exploring models and how to do this using tactical and strategic patterns.
    The consequences of users not being a domain concept which demands having a clearer language.
    Challenges of getting language and concepts to stick in business people’s minds.
    Refactoring code to reflect updated glossaries: Technical challenges teams doing DDD face.
    Switching paradigms from feature-based optimizations to building an amazing code core.
    Approaches to modeling: the value of exploring multiple models.
    How teams can become more efficient using DDD and extreme programming.
    Final plugs from Mark and how Agile DNA can help use Elixir to implement DDD.
    Pattern matching: Todd gets to know more about Chris Bell from ElixirTalk.
    How Chris got into programming, what he’d do if not be a programmer, and more!
    Why Chris loves history, dream pop, and what movie he’ll watch over and over.
    What project Chris is most excited about next: Building Settlers of Catan using LiveView.


    Links Mentioned in Today’s Episode:


    Elixir Wizards Listener Survey — https://smr.tl/podcastsurvey


    SmartLogic — https://smartlogic.io/
    Mark Windholtz on LinkedIn — https://www.linkedin.com/in/mwindholtz/
    Mark Windholtz on Twitter — https

    • 58 min
    Elixir Wizards Dojo: Nerves Part 2 with Connor Rigby and Todd Resudek

    Elixir Wizards Dojo: Nerves Part 2 with Connor Rigby and Todd Resudek

    Welcome to the second part of our special Elixir Wizards Dojo. A mashup made in partnership with ElixirConf Japan. In today’s episode, we talk to Nerves core team members Todd Resudek and Connor Rigby about all things Nerves. But first, Todd leads us into a delightful digression about his enjoyment of heavy metal music. From metal back to Nerves, Todd chats about how he uses Nerves to monitor his internet connection and to automatically restart his router when certain conditions are met. After talking about using Flutter and Dart to build GUIs, we ask Todd to share another of his Nerves projects; the future of sprinklers — the Drizzle 2000! We then explore Connor’s self-defined role in the Nerves team as the development head of networking libraries before discussing how easy it is to use Nerves if you are an Elixir user. Todd and Connor dive into their utopian visions for the future of Nerves and why no other IoT solutions can compete with the tooling that Nerves provides. We talk about FarmBot and the many features that its models have, including how they can pulverize weeds. This springboards the conversion into the increasing importance of IoT tech in the agriculture sector and how it’s likely to be the next billion-dollar industry. We round off the episode by giving our guests the space to plug themselves and they close with a request for listeners to Iron Maiden and Metallica’s first albums. A perfect compliment to the first installment of the Elixir Wizards Dojo, tune in to learn more about the Nerves Project.


    Key Points From This Episode:



    Introducing our guests and this episode’s connection to ElixirConf Japan.
    Connor and Todd lead a chat on the history and subgenres of heavy metal music.
    Todd talks about using Nerves to monitor his internet connection and restart his router.
    Building a user interface for Nerves’s projects using Flutter; Google’s UI toolkit.
    Best practices for developing apps with a specific focus on GUI apps.
    Hear about the Drizzle 2000! Todd’s sprinkler controller system that runs on Nerves.
    Todd and Connor’s respective roles as a part of the Nerves core team.
    The benefit of using Nerves; once it’s booted it’s a regular Elixir app.
    What a kiosk terminal is and how you would go about internationalizing one.
    Exploring the future of Nerves and hardware development.
    Comparing Nerves to other IoT solutions; in conclusion, nothing can compete.
    Different FarmBot system models that all use Nerves to grow food for you.
    Using Nerves to encode and record video or to create a live stream.
    Why integrating IoT into the agricultural sector will be the next billion-dollar industry.


    Links Mentioned in Today’s Episode:


    SmartLogic — https://smartlogic.io/
    ElixirConf — https://elixirconf.com/2020
    Connor Rigby GitHub — https://github.com/ConnorRigby
    Todd Resudek Twitter — https://twitter.com/sprsmpl
    Todd Resudek GitHub — https://github.com/supersimple
    Simplebet — https://simplebet.io/
    Flutter — https://flutter.dev/
    Binary Noggin — https://binarynoggin.com/
    Nerves Project — https://www.nerves-project.org/
    Nerves Project GitHub — https://github.com/nerves-project/nerves_pack#erlang-distribution
    Nerves Vintage Net GitHub — https://github.com/nerves-networking/vintage_net
    Nerves Web Kiosk GitHub — https://github.com/nerves-web-kiosk/kiosk_system_rpi3
    Rhapsody of Fire — https://www.rhapsodyoffire.com/
    Ronnie James Dio — https://www.ronniejamesdio.com/
    DragonForce — https://dragonforce.com/
    Black Sabbath — https://www.blacksabbath.com/
    Deep Purple — https://deeppurple.com/
    Iron Maiden — https://ironmaiden.com
    Judas Priest — http://www.judaspriest.com/home/
    Sam Dunn — https://www.imdb.com/name/nm0242757/
    Ryan Holiday — https://ryanholiday.net/
    Arjen Lucassen — https://www.arjenlucassen.com
    Metallica — https://www.metallica.com/
    San Francisco

    • 42 min

Top de podcasts em Tecnologia

Outros ouvintes também assinaram