Three Devs and a Maybe

In this weeks episode we are joined by good friend of the show Joe Watkins. We start off discussion with the successful release of PHP 7.1 and what is in store for Joe now as release manager for that version. Following this, we chat about the libui and Yubico PHP wrappers he as been working on and development of a better Raspberry Pi OS. Finally, we highlight progress made towards incorporating a JiT compiler within PHP and some interesting things you can do with Zero-width joiner’s and Emoji’s in Unicode.

In this weeks episode we start off by congratulating Mick on handing in his masters dissertation. We then move on to discuss decision trees, ordinal regression and genetic algorithms. Edd then mentions managing large tables in Postgres, MVCC, Fill factors and Vacuuming a table. From here we highlight an interesting JavaScript Unicode/New-Line length issue that occurred recently. Finally, we touch upon testing time-dependent processes in isolation, dreaded CRM integration and sign-up processes. Corrections: Couple of mistakes by Edd; its’ MVCC not MVVC, and any character that can’t be represented using 8 bits in PHP will have a strlen > 1.

In this weeks second in-person episode, we start off by congratulating Fraser on his recent engagement. We then move on to chat about setting up Kong, rate-limiting APIs and monitoring the health of an application system. From here we discuss the final stages of Mick’s masters dissertation, highlighting the PageRank paper and the Matthew (not Mafia) effect. Finally, we mention Edd’s trip to Silicon Milkroundabout and blog posts that he has recently had the chance to publish.

In this weeks episode Mick and Edd start off discussion with an update on Mick’s masters dissertation. We then move on to highlight the value of getting an MVP released, and the old adage that hindsight is 20/20. Edd then brings up how he has had the chance to revisit MyBuilder’s logging and monitoring infrastructure recently, re-accessing Severity levels along the way (embarrassingly missing out Critical in the podcast). He also mentions how background processes used within the application have changed overtime - discussing the difference between Time-dependent and Continuous processes. Finally, we chat about successfully introducing Supervisor into the stack and Erlang’s ‘Let it Crash’ philosophy.

In this weeks episode we are joined by Jonathan Klein to discuss his recently released Composer Pluralsight course. We start off by discussing the problem Composer is trying to solve, followed by past attempts at trying to solve it in the PHP landscape. Following this, we move on to discuss how the composer.json and composer.lock files work, the importance of versioning, the Semantic Versioning standard and how autoloading works. Finally, we delve into a couple of lesser-known Composer features, such as the event life-cycle, scripts and the plugin architecture that is present.

In this weeks episode we have a long overdue catch-up with Joe Watkins. We start off discussion with progress on PHP 7.1 and work Joe has been doing to provide an interface to libui within PHP. We then move on to chat about a couple of interesting RFC’s that are currently under-discussion, followed by managing long-running PHP processes with Supervisor and Unix signaling. Finally, we highlight how Garbage collection works and how PHP implements the concept to help manage memory.

In this weeks episode we start off discussion on the latest Apple event, what we think the next big product will be (the Apple Hat?!) and phone battery life woes. We then move on to chat about immutable design considerations, controlling mutation to aid performance and being bit by values vs. references. From here we highlight how profilers such as Blackfire are a great way of benchmarking/profiling your application - providing statistics over only your own intuitive claims. Finally, we mention database backup strategies, AVL trees and adding AirPlay support to your Vinyl deck.

In this weeks episode we start off the show by catching up on the ‘programming filled’ holidays both Edd and Mick have just come back from. We then move on to discuss Mick’s photo-shoot?!, Edd’s half-marathon training and highlight our deployment/testing processes. Finally we ‘Shave the Yak’ and discuss event-oriented system design - highlighting how it has been used in a recent project and the pros n’ cons of such an approach.

On this weeks episode we are lucky to be joined by Jason Marden, to discuss the world of Amazon Web Services. We start off the show talking about Jason’s recent visit to the AWS Summit in London, and what the talking points were from the conference. From here we delve into the Serverless Architecture, how AWS Lambda is paving the way of FAAS, containers and view-based aggregation services. The Immutable Server is next brought up, highlighting the change in deployment philosophy that can be achieved by using such a concept. Finally, we discuss the value of a good debugger, bringin’ back awesome screen-savers and the craze of Pokemon Go.

On this weeks show we start off discussion around what we have been up to away from the keyboard, and an update on Mick’s big freelance project. We then move on to the pros n’ cons of being tied into an ecosystem such as AWS, React performance, Micro-services and the expected FUD outcry when a web application makes a significant change. Finally, we chat about how important logging and monitoring are within an application, and how it can become tricker to track down issues when a system is sufficiently large or a sum of many parts.

In this weeks episode we are lucky to be joined by Jimmy Burrell for a long over-due ‘geek out’. We start off discussion around his recent functional programming exploration, and how you can take many of these principles into your day-to-day OOP language. Following this we chat about what drew Jimmy to F#, the REPL, making illegal states unrepresentable and reasoning about immutable data-structures. From here we highlight some of F# capabilities including, pattern matching, computational expressions, type providers, currying and concurrency paradigms. Finally, we wrap up the show discussing our experiences learning about monads, the continuation passing style, and thinking in terms of data transformations.

In this weeks episode we are lucky to be joined by Joe Watkins. We start off discussion around the development of PHP 7.1 and the recent initial alpha release. Following this, we give an update on a couple of previously mentioned RFC’s, along with how Joe’s ones are doing. This leads us on to highlight how some small proposed changes are paving the way to optimal machine-code and finally integration of a JIT compiler. Some of these proposed changes may result in backwards compatibility breaks, we discuss this topic and when it is deemed acceptable to permit this. Finally, we chat about memorisation, caching and how it is not really feasible to distill a standard caching interface that fits all requirements.

In this weeks episode we are very lucky to be joined by Bruce Momjian to discuss Postgres Performance Tuning and Query Planner. We start off discussion around how Bruce got interested in Database Systems, a brief history of Postgres and his involvement with the project over the years. Following this we highlight the three main areas which affect database performance - hardware, server configuration and SQL/indexing. With this knowledge in hand, we then delve into the Query Planner, demystifying some of the terminology and concepts used (i.e. cost, scan methods and join methods). Finally, we summarise how these concepts are used by Postgres to decide which query plan to pick for a supplied query.

In this weeks episode we talk to Juho Vepsäläinen about all things Webpack. We start off discussion with how he got into JavaScript and what drew him to write the SurviveJS books. Moving onto Webpack, we chat about the problem it is trying to solve, what a bundler is and how it differs from a task runner. We highlight some of the interesting features that Webpack has to offer such as bundle splitting, integration with UglifyJS/Babel and lazy loading. Finally, we discuss the road-map for Webpack 2, new concepts which are being integrated such as tree shaking for dead code elimination and weighing up use of CDN’s for dependencies.

We have a full host podcast for the 100th episode! Starting off the show by thanking all of our previous guests and you the audience, we then move on to discuss our recent catchup in-person and reflection on the past three years of podcasting. During which, we have a déjà-vu moment with another audio blip similar to what occurred in the first episode. This leads us on to discuss testing in React/Flux and moving away from the reliance on jQuery as a dependency. Edd has ran some stats on the previous 99 episodes and with these results we then have a quick quiz. Finally, we discuss how/why we started the podcast in the first place, encourage anyone who is thinking of starting a podcast to do it and bring back hot picks of the week!

On this weeks episode we are lucky to be joined by good friend of the show Justin DeLucia. We start off discussion with what Fraser has been up-to recently, porting a code-base over to Webpack and experimenting with VR headsets. This leads us on to chat about Justin’s recent move to Wales, reflecting on his experiences working remotely, the value of communication and how he now handles clients. Finally, Justin then highlights the differences in work and web cultures in his new surroundings and the pros n’ cons he has faced since moving away from the office setting.

On this weeks episode Edd and Mick start off discussion around productivity, quick feedback cycles with clients and building pizza ovens. We then move on to chat about how Edd ‘maybe’ accident prone, how MVCC works at a high-level and why you need to vacuum your tables in Postgres. Finally, we bring up Uncle Bob’s recent ‘Type Wars’ article and highlight the different variants of typing (static, dynamic, weak and strong).

In this episode we are joined by Joe Watkins to discuss the many RFC’s that are in contention to be approved for PHP 7.1. We start off with a congratulations to Joe for his first PHP Release Manager position, highlighting what the role entails and how it is going. We then discuss the RFC process and how there has been a lot of activity over the past couple of weeks within this space. The concept of ‘Null’ is the first group of RFC’s we discuss, followed by union/intersection types and the pipe operator. We then move on to chat about short closure syntax, functional interfaces and lexical scope within anonymous classes. Finally, we bring up the comparable RFC which has been around for many years and the benefits of having attributes within the language.

On this weeks episode we are joined by Jonathan Klein to discuss all things application performance. We start off the show with chat about how he got into performance, why it is so important and how he thinks of it throughout the development process. From here we discuss his recently released Pluralsight course on ‘High Performance PHP’ and touch upon some of the key performance areas within the stack. Starting with micro-optimisations at the code level, we highlight their value and caching mechanisms. We then move onto the web server, process managers and the importance of a correct configuration. The Database layer is then brought up, discussing forks of MySQL, handling slow-queries and data-denormalizations. Finally, profiling and monitoring tools are discussed (such as New Relic and Seige) and where you can typically find the most wins within a typical stack.

On this weeks episode we are lucky to be joined by Matt Davis. We start off the show with discussion surrounding how Matt got into programming, the Symfony certification system and his experiences working with both Symfony and Laravel. With Edd’s recent guest appearance on Full Stack Radio just being released, we then touch upon this experience and the PostgreSQL topics covered. Following this we chat about working with external API’s, testing logic dependent on these services and how Matt has been using RabbitMQ and the Laravel Queue abstraction. This leads us on to discuss the concept of queued work in more depth, along with how to design computation in such a manner. Finally, we chat about the pros n’ cons of moving away from jQuery and back to vanilla JavaScript.

In this weeks episode Edd and Lew start off discussion with the topic of relying on external dependencies within a project - explaining issues surrounding this practice and mitigating problems that may arise. We then move on to chat about getting away from build systems such as Gulp, by writing your own simple build scripts which are project specific. From here Edd mentions a simple game he created to explore using State vs. Props in React, and how interesting solutions to some-what simple problems develop overtime. Finally, we delve into more PostgreSQL discussion and the world of statistics, highlighting the differences between cohort and time-based analysis.

On this episode (where Edd says ‘You Know’ alot!) we start off with discussion surrounding Lew’s recent move. Following this, we chat about odd IE 9 bugs, PostgreSQL Query Optimiser internals, the NPM left-pad saga and Lumen. This leads us on to discuss different Database GUI applications, Lew’s fun with public-key API authentication and the anti-pattern of striving for ‘pretty’ URLs. Finally, we bring up the topic of handling email delivery, using DigitalOcean to host podcast episodes and an interesting tidbit on the ‘break’ control structure in PHP.

In this week’s episode we start off discussion with a recent PHP RFC Joe has been working on in-regard to typed properties, bringing up the value (if any) surrounding getters and setters. We then move on to Joe’s views on designing a programming language, and his mind-set that there should be no defined scope surrounding the features that the language should adopt. Finally, we wrap up the show with an update on how stabilisation of uopz is going for PHP 7, along with a reflection on the ‘Hacking on PHP 7’ screencasts we released earlier this month.

In this week’s episode we start off the show with chat about Fraser’s recent work event up in Newcastle and his experiences with Raspberry Pi’s, Bluetooth Beacons and Promise Library memory-leaks. We then move on to chat about how large the JavaScript landscape has become, Mick’s experience at the PHP UK Conference he recently attended and his new found interest in Microservices. This leads us on to discuss techniques used to manage application logs, teaching a ‘non-techie’ person some web programming and visualizing sorting algorithms. Finally, we wrap up the show with chat about product release cycles, product owners and QA teams.

In this weeks episode Edd is joined by podcast regular Joe Watkins. We start off catching up with what Joe has been upto since we last spoke, and his current experiences with upgrading a legacy code-base to PHP 7. Discussion about the stability of ‘uopz’ in-regard to PHP 7 is then highlighted, followed by his recent mentoring on a data-structures extension which has been met by much phrase. Joe discusses the goals behind the extension and how the developer (Rudi Theunissen) has done a great job in designing and describing the implementation. Following this, we chat about the draft Code of Conduct RFC that Anthony Ferrara proposed earlier this year (since taken over by Derick Rethans), which has been subject to much debate. Finally, we dive into a couple of other new RFC’s that are in-discussion or recently accepted into the next release.

In this week’s episode we are very lucky to be joined by William Thomas, designer and colleague of Edd’s at MyBuilder. We start off discussion with how he got into design - creating promotional band material and games with his brother. Following on from this we talk about his introduction to Web Design during University, exploring and pushing his understanding of markup and CSS through small web-projects. Will then explains how he feels design is more of a science than an art-form, using empirical data to aid decisions and how he has had learn to manage client expectations. From here we discuss what/who he looks to for inspiration and how he feels going to conferences to be a good aid. Having started off using markup and CSS we chat about his transition to using tools such as Sketch, why he prefers it over Photoshop and how it has become an integral part of his design process. Finally, we chat about the relationship between a designer and developer, resources for developers who wish to gain a better understanding of the work that goes into design, and his experiences working in both an agency and product based setting.

In this weeks show we start off the podcast with discussion on SQL performance, different types of join and effective indexing based on the query planner. We then move on to Mick’s success with using Let’s Encrypt on his personal site, along with some interesting talking points he picked up in a recent book he has been reading. Returning ‘$this’ from a method call is then discussed - were we debate about being strict on the API’s you design. Finally, Fraser chats about another successful feature being developed in a TDD manner, fun with eyeBeacons and disadvantages to DocBlocks/Comments as Code.

Apologies for Edd’s awful audio echo this week, serves him right for trying to bring sound-drops to the podcast. On the first full host podcast of the year we start of discussion with what Fraser has been up to these past couple of months, his exciting new job promotion and how he is enjoying development. We then move on to chat about some Agile methodologies (Scrum, Kanban Boards and Sprints), Babel/Webpack and the release of Space Beer Cave into the iTunes App Store. Lewis then brings up his recent exploration into TDD, followed by Mick’s look into OAuth 2 and pains with the PostgreSQL query planner. Finally, we chat about logging and debugging errors which occur in production, and how burnout and technical debt can be similarly compared. Competition: With the release of Space Beer Cave into the iTunes App Store, Fraser has decided to make another competition for the highest score that is screen-shot and tweeted to our podcast account. The winner will receive their very own Three Devs and a Maybe t-shirt! the competition ends on the 4th March.

On this weeks show we are lucky to be joined by Camille Baldock to discuss all things API related. We start off the podcast with discussion on how she got into programming and her first experiences with API Development. We then move on to chat about SOAP, REST, HATEOAS and the Richardson Maturity Model. This leads us on to HyperMedia APIs, highlighting the different format types (JSON-LD, HAL, Collection+JSON, SIREN…) currently available, common misconceptions and API design tooling (Swagger, API Blueprint, RAML…). Finally, we wrap up the show with a brief chat about Micro-services.

On this weeks show we start off with Mick’s recent dive into React, discussing alternatives in process. We then move on to chat about large database design, seeding databases, clean installing a Mac and external SSDs. Following this, Edd brings up his exploration into Macros in Clojure, Immutable data-structures and interesting behavior with ‘this’ in JavaScript. Finally, we wrap up the show by bringing up the topic of being in ‘The Zone’ when programming, what we feel about the concept, and the pros n’ cons of such a mind-set.

In this years first episode we start off the show with discussion on Lew’s newly updated website, Bowling Game Code Katas and PostgreSQL. We then move on to talk about React-Router, ‘shrinkwrapping’ NPM dependences and Edd’s introduction to the world of Lisp by way of Clojure. Other coding katas are then mentioned (FizzBuzz), along with an interesting project good friend of the show Jimmy Burrell has recently released. Finally, we wrap up the show with ideas on the technologies and languages each of us wishes to explore this year, along with some interesting podcast episodes we have recently listened to.

This week we are very lucky to have Ahmad Nassri on the show to discuss the world of API’s and how Kong (the API/Microservice management layer) fits into the picture. We start of discussion with how he got into programming and garnered an entrepreneurial spirit in his homeland of Syria, before moving to Canada in his late teens. Following this we chat about his current companies (Mashape) approach to development, picking the right stack and language for the job at hand. Throughout these experiences and their central ‘Marketplace’ product Kong has been developed, helping unify similar API requirements such as logging, authentication and request transformations. As the word ‘microservices’ has been brought up, discussion then centers around his definition of the term and the three pillars (modularization, componentisation, services) he sees there being. We then move on to the decisions behind using Nginx and Lua as the base for Kong’s development, along with a look into the Lua ecosystem and Mashape’s many contributions. Finally, we chat about Kong’s plugin architecture and the vibrant community/projects that have been created since its initial inception.

On this week’s show we are joined by Mattias Geniar to discuss all things HTTP2. We start of the show with discussion on how he got into programming, moving into a DevsOps role as his career has progressed. From here we briefly discuss the term DevOps and how he uses a lot of Puppet in his current role. This leads us into chat about a host of topics revolved around HTTP, the history, TCP, the OSI model and ‘best practices’ in regard to HTTP 1.1 usage. We then move on to discuss the HTTP2 protocol, the changes that have been made, how easy it is to adopt and how our typical tooling works with the new standard. Finally, we wrap up the show with discussion on TLS and how/why it has almost become a ‘de-facto’ standard for the HTTP2 protocol, along with the different servers that have appeared since its inception.

On this week’s ramble podcast we are joined by the Macintosh Speech Synthesis Manager!? We start of the show with discussion on dedicated full-text indexing search solutions, followed by conversation on random domains that we may have purchased in the past. We then move on to chat about blogging solutions, the small refactoring cycles vs. full rewrites decision and what a design pattern truly is. Edd then goes off on a tangent about the ‘curse’ of the DRY principle, followed by the use of traits over conventional OOP concepts. Finally, we wrap up the show touching upon HTTP and how it is favourable to try and put off caching until it is justifiably needed.

In this week’s show we are lucky to be joined by Andrew D’Amelio, to discuss all things Ramda and ‘Hardcore’ Functional Programming. We start off discussion with how he got into programming, growing up with lecturers telling him that JavaScript was just a flash in the pan. Leading on from this we delve into how he quit his previous job to take 6 months off, investing time into learning AngularJS due to its heavy job demand. Throughout this time he was able to learn a lot from the Frontend Masters courses, with aid from AngularJS’s opinionated approach. We then move on to discuss the philosophy behind Ramda, introduced to him within the Hardcore Functional Programming course provided by Frontend Masters - and how it promotes code reuse by way of composition. This interest into the library brought him to introduce it to colleagues in a lunch n’ learn, paving the way for deployment into production. Andrew then highlights how it performed in production, along with his experiences debugging code written with it. Finally, we finish off the show touching upon type transformations and how his current workplace are using TypeScript and Flow to harness typing. We then conclude on how Ramda is a great gateway into many advanced functional concepts, using a language that feels ‘safe’ as opposed to taking an even bigger dive into Haskell and Lisp dialects.

In this week’s show we start off discussion with Lew’s upgraded audio and Mick’s side-project ‘Smuddle’ which hopes to help fill a void in the shopping comparison site area. We then move on to touch upon third-party email delivery solutions, task scheduling abstractions and queuing implementations. API’s and the tooling around them is next on the list along with how the JavaScript stack can be quite intimidating when you first delve into it. Finally, we chat briefly about Hypermedia API’s and look into developing and deploying web applications outside of the PHP ecosystem.

On this weeks show we are lucky to be joined by recurring guest and friend of the show Joe Watkins. We start of discussion with the upcoming PHP 7 release, reasoning behind why it has been postponed, the bright future of adoption to the release compared to previous versions and how the release gets packaged up for different distributions. We then move on to touch upon uopz (User Operations for Zend), how it helps aid getting code ‘under-test’ and the progress made to make it compatible with PHP 7. The pthreads polyfill and work on a new project called ‘inspector’ are next on the list, with the history behind how inspector started from the concept of serialising functions/closures. Finally, we chat about the recent APCu events and additions, highlighting different forms of locking in the process - followed by what interesting topics he wishes to explore in the future.

On this weeks episode we are lucky to be joined by Dan Abramov, creator of Redux and React Hot Loader (React Transform). We start off the show with his upcoming move to work at Facebook in London, and touch upon how he became interested in programming from a young-age. Following this we discuss his transition from VBA, to C# and then JavaScript - by-way of CoffeeScript and a BackboneJS application he was working on. Issues with the complexity of asynchronous logic and hard-to-reproduce bugs lead him to invest time in exploring React. We then talk about the problem React solves and how its’ pragmatic approach (including escape-hatches) can easily propagate up your code-tree. Successful use of React was followed by exploring Flux and we highlight how it forces data-mutations to follow a strict-cycle. We discuss the history of different Flux implementations and how he went about eventually making his own (Redux) for a recent talk he gave. Finally, we wrap up the show highlighting his work with React Hot Loader and its successor React Transform, along with recommended resources for beginners looking to explore these subjects in more detail.

This week we are very lucky to have Lewis back on the show after his recent move. We discuss what he has been getting up to in his absence and how he is balancing work/life whilst being remote. Following this, we touch upon a reinvigorated passion for software architecture, moving to a framework from bespoke solutions and the middleware pattern. Discussion then turns towards moving from AngularJS to React/Flux and resources Edd has written and found useful whilst learning the subject. Security is the next hot-topic with the recent TalkTalk security breach in question, an interesting pseudo-random number seed issue and SSL/TLS/HTTPS all explained. Finally, we conclude with an update on Mick’s final year project and his work with decision trees.

On this weeks show we start off proceedings with Edd’s experience developing and deploying a JavaScript centric application - mentioning an example application he is currently working on to document use of Flux, React, Webpack and Karma. We then move on to highlight the sites hosting switch to Jekyll and S3, and how we have been able to get download statistics back thanks to S3Stat. Following on from this we discuss configuration formats, how Mick was able to get disconnected by his ISP due to his finial year project and Fraser’s exploration into Ionic. Finally, we wrap up the show touching upon the Natural Computation book Edd is currently reading and a couple of interesting developer related shows available on BBC Radio 4.

On this weeks episode we are lucky to finally be in the same room recording the podcast in person, apologies for the low volume. We start off discussion with the Drobo, BeyondRAID, how hard giving estimates is, ‘bad’ code and impostor syndrome. Following on from this is a brief history behind the Mozilla name and Netscape, along with how bullish Microsoft was in the 90’s. This leads us on to talk about TDD coding katas, the current state of testing in JavaScript and Android fragmentation. Finally, we finish up the show with Hypermedia endpoints (HAL), and epic Microsoft Office - El Capitan bugs.

In this episode we are lucky to be joined by good friend of the show Joe Watkins. We start off the podcast discussing the recent major release of pthreads (version 3) and the differences found compared to version 2. This moves us on to touch upon the design decisions made due to changes between PHP 5 and 7, providing a good API to the user, volatility and immutability considerations and installing extensions within PHP 7. We finally bring up the progress being made in moving over other extensions such as APCu and uopz, helping out with other projects such as Xdebug and our delve into screencasting.

This week we start off discussion with the topic of CSRF and Session hijacking. We then move on to the recently released screencasts we did with Joe Watkins, and how interesting Edd found recording them. Following this we discuss ReactJS, the Flux architecture, handling error-logging on the front-end and the JavaScript source-maps. We wrap up the show with the emphasis of removing jQuery, how hard following a single source of truth is and ‘dangerous’ design patterns.

This week we are very lucky to be joined by fellow podcaster and host of Functional Geekery - Steven Proctor. We start off discussion with how he got into programming from a young age, and how a 100 dollar experiment turned into the Functional Geekery podcast we know today. This moves us on to chat about Erlang/OTP and how the Actor model is used to provide such a robust language infrastructure. Finally, we speak about how fundamental principles out-weigh concrete implementation knowledge and Proctor gives us a host of resource material for interested listeners to delve into.

This week we are joined by Jordi Boggiano, Composer (Dependency Manager for PHP) lead and Symfony2 core developer. We begin discussion with how he got into software development, touching on his involvement with Symfony2 before its official release. This topic leads us on to chat about why Composer was developed and how much it has grown in popularity. Jordi then discusses some of the changes he would make if he had the chance, along with what the Toran Proxy is. Finally, we discuss Composer performance and the popular Monolog package that he has developed.

This week we are very lucky to be joined by long-time listener of the show Jimmy Burrell. We start of discussion with interesting use-cases for monkey-patching in PHP and your responsibility to written code. From this we move on to chat about HostSignalz, touching on Jimmy’s experience developing within Visual Studio and the Windows platform. Jimmy then discusses his journey into software development and how he stays up-to-date with the latest technologies. Finally, we announce the winner of the recent Space Beer Cave T-shirt competition and somehow get onto the topic of Michael Jordans career.

This week we are very lucky to be joined by fellow podcaster and host of Full Stack Radio - Adam Wathan. We begin discussion with his reasons behind starting a podcast, experience being a solo-host and the secret to great podcast recordings. We then move on to how he got into programming at high school - with reflection on that if he had been using a Windows machine at college, he would most likely be a .NET developer by now. As both Edd and Adam work remotely at this time, the topic of remote pair-programming and Kanban style board implementations then arises. Finally, we discuss his thoughts on Message-passing vs. strict-contracts, Smalltalk and Elixir exploration and how it is hard to give a definitive answer on the best way to begin learning TDD.

This week we are lucky to have good friend of Edd’s, Jason Marden on the show. We start of discussion with how he got into programming (hacking on Flash games) and how we met at University studying for a Computer Science degree. Moving on from this, we touch upon being introduced to Java as a first language, the presence of UML/SOAP in the real world and the importance of a white-board. Finally, we wrap up the show with chat about Test Doubles, how his work provisions their AWS setup and advice to people looking into getting into the industry from University or another profession.

This week on a early Sunday morning recording, we start off podcast discussion with A/B testing and Google Analytics/Experiments. We then move on to touch upon distributing PHP console applications within PHAR’s, application security and Google’s recent IO conference. Following this we bring up a couple of small projects Edd is currently working on, relating to Morse Code and Colour detection algorithms. Finally, we wrap up the show by discussing the current Space Beer Cave competition that is still underway, and how one contestant is running away with the prize at this time.

In this weeks show we are lucky to have good friend of the podcast, Justin DeLucia back on. Although he is sadly only able to stay around for half the episode, we are able to touch upon some very interesting topics in this time. Initially starting off with discussion on baby sleeping patterns, we move on to the role of the designer and how it is slowly changing. We follow this up with Justin’s thoughts on animation within web design, and the trends he sees forming in 2015. This leads us on to bring up the topic of mobile traffic, and how more and more users are relying on only an mobile experience. Finally, we discuss Michael’s experiences throughout his first two years into a graduate masters degree, and how above all else learning takes precedence over grades.