Three Devs and a Maybe: Recent Episodes
Michael Budd, Fraser Hart, Lewis Cains, Edd Mann
Join us each week as we discuss all things software development. Frequently joined by a far more intelligent guest on the show's topic, we by no means know everything, but love what we do. Topics range from daily developer life, PHP, frameworks, testing, good software design and our experiences using many other programming languages.
In this weeks episode we are lucky to have Keyvan Akbary back on the show. We start off by discussing the job role he has taken since moving back to Madrid, and the importance of building autonomous teams. From here, we talk about the technology stack they are using at Cabify, highlighting some of the interesting features found in Elixir and Go. Finally, we touch upon Cabify’s infrastructure and deployment strategy, showcasing how awesome GitLab is along the way.
In this weeks episode we chat to Simon Bennett about his experience bootstrapping SaaS products. We start off with how he got into software development and highlight some of his previous/current business ventures. This leads us to highlight treating each failure as an experiment, and the danger (as a developer) of using a new product idea as a platform to learn new technology. From here, we discuss the success he has had from SnapShooter, his new product Automaily, and the unique challenges building products targeted at developers. Finally, we touch upon how he comes up with new ideas, the necessity to quickly validate them, and advice for any listener who has an idea and is thinking of building a product from it.
In this weeks episode we have good friend of the show Joe Watkins back on to discuss the recent developments in PHP. We start off by highlighting how code is currently compiled and executed using the Zend VM, and distill how the recently approved JIT (for PHP 8) will change this. From here we mention the reasoning for going down this path now, the difference between I/O vs CPU bound code, and the use-cases where the JIT will improve performance. This leads us to the PHP compiler project Anthony Ferrara is working on (with the goal of Ahead-of-Time PHP compilation), and the new parallel concurrency API Joe is working on which uses a model similar to Goroutines. Finally, we discuss his recently approved Weak References and Abolish Narrow Margins RFC’s.
In this weeks episode we are lucky to have Mattias Geniar back on the show to discuss his experiences delving into Bitcoin and Cryptocurrencies. We start off by chatting about his introduction to Bitcoin, the ‘bear market’ of 2018 and how valuable the ‘Mastering Bitcoin’ book is to understanding its’ internals. From here we move on to the concept of ‘Code is Law’ and the implications of such an approach, the pros n’ cons of being a developer in this space, and how he stores his private keys (not your keys, not your coins!). This leads us to highlight second-layer scaling solutions such as the Lighting Network, and the confusion around projects reusing the Bitcoin name. We then touch upon the power of Ethereum, its’ planned consensus transition from PoW to PoS, and how different it is developing on a distributed platform. Finally, we look at the Mimblewimble protocol and Atomic Swaps, discussing their use-cases and how they can improve the space.
In this weeks episode we are lucky to have both Matthieu Napoli and Neal Brooks on the show to discuss all things Serverless PHP. We start off by discussing what drew Matthieu to Serverless, the creation of the Bref project and the technical challenges encountered with getting PHP to work within the Lambda environment. From here, we touch upon the reasons behind moving from the Serverless Framework to SAM (for the 0.3 release) and how Bref uses the new Lambda Layers and Runtime API. This leads us on to highlight how a typical PHP project would use Bref, the decision to be opinionated in order to stay minimal and the experimental Loop SAPI. Finally, we envision what the future holds for the Bref project and Serverless compute.
In this weeks episode we are joined by Joe Watkins for a long overdue catchup. We start off the show by discussing what Sandboxing is and the new Sandbox extension he has developed. From here, we touch upon test-doubles/mocking frameworks, the reasoning behind building uopz in the past, and now componere/mimus to aid in testing. This leads us on to highlight what test coverage is, the history of coverage tooling within PHP, and the new exciting pcov extension he has released. Finally, we do a big ol’ RFC roundup, discussing RFCs that have been accepted for PHP 7.4 (FFI, Typed Properties and Preloading) and ones under discussion (JIT and Weak References).
In this weeks episode we are lucky to have Matthias Noback on the show to discuss software architecture design. We start off the show by highlighting why we should invest time in the architecture of our software, and what is meant by ‘layers’ of an application. This leads us to discuss what Hexagonal Architecture (Ports and Adapters) actually is, Infrastructure vs. Core (Domain, Application) and the Dependency Inversion Principle. From here we mention the different responsibilities Ports and Adapters have, the different forms of testing you can do within this architecture and Use-cases/Command Buses. Finally, we touch upon the new book ‘Style Guide for Object Design’, which Matthias is currently in the process of writing.
In this week’s episode Edd and guest co-host Neal Brooks chat to Nicolas Grekas about all things Symfony. We start off discussion with how he got interested in programming, his introduction to Symfony, and his journey to now working on the code-base almost daily. This leads us on to talk about how he helped build the performance profiler Blackfire, and the importance of quantitative measurements whilst making performance improvements. From here we highlight managing pull requests, the social factors when leading open-source projects and Symfony’s continuous migration path. Finally, we touch upon the recently released Messenger component and upcoming Symfony Contracts initiative.
In this weeks episode we are lucky to be joined by Neal Brooks, a fellow developer of Edd’s at MyBuilder. We start off by discussing how he got into programming, QBasic and video driver shenanigans. From here, we move on to introduce his SymfonyLive London talk ‘Running Symfony on AWS Lambda’. We highlight what drew him to Lambda, and the new tooling that is making it easier to run PHP and frameworks (such as Symfony) on it. This leads us to cover his demo application, and explore handling assets using S3, database migrations and AWS resources using CloudFormation. Finally, we debate using catch-all gateway endpoints vs. dedicated gateway endpoints and Lambda performance.
In this weeks episode we are lucky to be joined by Scott Arciszewski to discuss all things Security. We start off by chatting about a recent talk he gave at DEF CON 25 and the importance of secure API design. From here we highlight Google Tink, misunderstandings of how PHP has changed over the years and what CVE’s are. This leads us on to delve into the tools and processes used within the reconnaissance phase of a security engagement. Finally, we briefly mention Quantum Computing and its impact on cryptography - followed by best practises for securely managing secrets within web applications.
In this weeks episode we are lucky to have Scott Wlaschin back on the show to discuss his most recent talk ‘Four Languages from Forty Years Ago’. We start off by talking about why the 1970’s was such an influential decade for language design. This leads us on to highlight what a programming language fundamentally is, and explain the many different paradigms that are present. From here, we explain the issue with throwing out the design phase completely when building software, and the interesting points made in Richard Gabriel’s ‘Worse is Better’ essay. Finally, we try to make sense of why all popular programming languages today follow a very similar style, and what is with all the curly braces?!
In this weeks episode we start off discussion around testing in a Continuous Integration pipeline, and setting up a personal Bamboo CI system. We then move on to separating domain logic from the delivery, and how a Package-Bridge-Delivery split works. After a small mouse related intermission, we touch upon experiences building custom Babel plugins and testing using Jest, Travis CI and Docker. Finally, we highlight creating small CLI applications with Go, Serverless Offline and Logic-Gates/8-bit computers.
In this weeks episode Mick and Edd have a long overdue catchup! We start off the show by discussing Mick’s new job, the new stack he is using, and the benefits of working in a team. From here we highlight how his company uses Scrum (Sprints, Planning Poker and Story Points), handling event-sourced models with the introduction of GDPR, and logic within annotations. Finally, we touch upon Edd’s recent engagement and marathon, a new Serverless/React blog series he is working on, developing applications for the Ethereum blockchain, and how to manage application secrets.
In this weeks episode we are lucky to be joined by Alex Bilbie to discuss all things AWS, Golang and iOS development. We start off the show by exploring how he got into programming, the stack he currently uses, and moving from a Monolith Laravel application to Golang microservices (deployed using ECS). From here, we move on to highlight his time developing the popular PHP OAuth 2.0 Server package, and how he first got interested in the AWS platform. We then discuss the power of composing services offered by AWS together, the concept of being ‘cloud-proof’ and the AWS certification system. Finally, we talk about his upcoming S3 master-class video series, use of Terraform for IaC and experiences building/shipping an iOS application.
In this weeks episode we catch-up with Joe Watkins. We start off discussion with a recent blog post he wrote about the unhelpful ‘just because you can, doesn’t mean you should’ response he sees surrounding some of his PHP extensions. From here we move on to highlight a debugger you can ‘composer require’, reasons behind creating such a tool and how it works. This leads us on to mention some updates to uopz for PHP 7 support, a weak references RFC he has recently published and future plans for PHP. Finally, we wrap up by talking about a CommonMark extension he has published, and how CQL provides the ability to efficiently traverse a document.
In this weeks episode we are lucky to have Scott Wlaschin back on the show to discuss design within software. We start off by highlighting leaky abstractions, adopted tool-chains and transpiling languages into JavaScript. From here we move on to talk about what makes ‘good code’, and how evaluating this is heavily reliant on the requirements and context you are in. Finally, we discuss how OO and FP software architectures differ, advantages of being explicit over implicit and information-hiding at API boundaries.
In this week’s episode we are lucky to be joined by Niall Murphy to discuss the discipline of Site Reliability Engineering. We start off by speaking about how he got into computing, how the SRE role came to be and what drew him to it. From here, we highlight the position of an SRE within a company/group, what SLA’s are, the positives of having 50% operations work caps and blameless postmortems. This leads us to talk about the reasoning behind striving for 100% uptime is actually detrimental to the product, and the benefits of having an Error Budget. Finally, we discuss how the role has evolved since its inception, the Wheel of Misfortune and what drew him to contribute to the seminal SRE book.
In this week’s episode we are lucky to have Jay Smith back on the show to talk all things cryptocurrency. We start off the podcast by briefly recapping what’s been happening within the space since we last spoke. This leads us to discuss the Lighting Network running on the Bitcoin Mainnet, CryptoKitties, ERC-721 tokens and Ethereum Casper. From here we chat about Proof of Work, the environmental impacts of the protocol and how Proof of Stake differs. Finally, we chat about Web3, experiences using PIVX, Steemit and IPFS.
In this weeks episode we are joined again by Brian Moses to discuss several of his recent system builds. We start off the show delving into his recent EconoNAS, highlighting the goals behind the build and how he goes about selecting the hardware parts. We then discuss his experience using White-label HDD’s for the first time. From here, we move on to discuss his HTPC - again highlighting the goals and the experience of live-streaming the build. This leads us on to highlight the AMD Ryzen Threadripper/Intel Coffee Lake i9 series of CPU’s, Graphics card pricing and the Steam Link Box. Finally, we look at what’s in store for his upcoming DIY NAS 2018 build, FreeNAS AMD support and the different available SSD connectors.
In this weeks episode we are lucky to have Scott Wlaschin back on the show. We start of discussion by highlighting his most recent talk on composition and some useful analogies to Lego, Brio and Unix. From here we move on to investigate function and type composition, the difference between a paradigm shift compared to simply a syntax one and the advantages of an opinionated language. This leads us on to mention how within application design pushing the side-effects to the edge and keeping the core domain pure is beneficial. Finally, we touch upon testing in functional languages, experiences whilst consulting and Rich Hickey’s ‘Effective Programs’ talk.
In this weeks episode we are joined by Thijs Feryn to discuss his upcoming PHP UK conference talk. We start of the show highlighting what drew him to a Tech. evangelist role, bridging the gap between code/infrastructure and the ideas behind ‘Infrastructure as Code’. From here we move on to discuss system and infrastructure provisioning automation tools such Ansible and Terraform. This leads on to adding Packer into the mix, moving towards immutable infrastructure, testing these automation tools and how history has a way of repeating itself. Finally, we touch upon the philosophy behind DevOps, focusing on empathy and its core values CAMS.
In this weeks episode we are lucky to be joined again by Scott Arciszewski. We start off the show by discussing the difference between Symmetric and Asymmetric Encryption, what Authenticated Encryption is and how secret-keys are exchanged using Diffie-Hellman. From here, we move on to highlight how Elliptic-curve cryptography works, what DNSCrypt is and why prime numbers are so important in cryptography. Finally, we touch upon multi-factor authentication, how one time passwords work, SMS vulnerabilities and how to manage password recovery.
In this weeks episode we chat to Scott Wlaschin about his new book ‘Domain Modeling Made Functional’. We start off the show discussing how the book came to be, the process of writing a book and melding the worlds of Domain Modeling/Functional Programing. This leads us on to highlight what Domain Driven Design is, the importance of communication and the difference between the solution/problem space to garner a shared model. Finally, we touch upon some of the common patterns that come out of modeling domains such as - how Entities and Value Objects provide identity, maintaing invariants using Aggregates, and communication between modals via Anti-Corruption Layers.
In this weeks episode we continue our discussion with Scott Arciszewski about all things Security and Cryptography. We start off the show by highlighting what a SQL injection attack is and the differences between (emulated) prepared statements. This leads us on to look into how to securely handle file uploads, what a reverse shell is and how to defend yourself against XSS/CSRF attacks. From here we touch upon the recent inclusion of libsodium into PHP, why mcrypt should be avoided, and the side-channel vulnerabilities that brought way to Meltdown and Spectre. Finally, we mention how computers generate seemingly random numbers, what a Web Application Firewall (WAF) is, and how WARD goes about protecting your systems.
In this weeks episode we chat with Scott Arciszewski about all things Security and Cryptography. We start off the show by explaining how he got interested in this field of work, correcting PHP security related answers on Stack Overflow and why he focuses on PHP security. From here, we move on to highlight what the OWASP Top Ten is, how you can distill many security principles into data/code seperation and what is involved in a software audit. This leads us on to discuss what HTTPS actually is, touching on TLS, PKI’s, Ciphersuites, and reported attacks against TLS and ECB. Finally, we highlight some important browser security features that can be used, pushing new software releases in a secure manor, thoughts on Cryptocurrencies and how everyone wants to solve their problem with a blockchain at this time.
In this episode we catch up with Joe Watkins to discuss all things PHP. We start off discussion with his recent move to Spain, the pain of getting a good Internet connection and PHP TestFest. This leads us on to highlight some recent work he is doing with adding PHP bindings to Bicoin’s Secp256k1 library and a Generic Traits idea. From here we touch upon the additions that made it into PHP 7.2 and some that have already been accepted for 7.3. Finally, we get Joe’s opinion on a couple of RFC’s (Call-site pass-by-reference and Operator functions).
In this weeks episode we chat to Andy Raines about all things Serverless. We start off by discussing what Serverless actually means, advantages of using such a model, design constraints it employs and how it scales. From here we touch upon the history of how we got to the compute/infrastructure we use today: from on-premise servers, IaaS, PaaS and FaaS/BaaS. This leads us on to highlight the 12-factor app methodology, how immutability has vast benefits in many contexts and how FaaS platforms work under-the-hood. Finally, we mention the Serverless PHP project Andy is working on, the motivations behind it and future development he would like to see take place.
In this weeks episode Mick and Edd first touch upon the many new services/features that have been released at AWS re:Invent. We then move on to discuss Serverless architecture, Server architectural patterns, Amazon Cognito and security/encryption that is available within Amazon Web Services. This leads us on to highlight the impact of relying on a single company for all your compute/infrastructure needs and ‘putting all your fish in one basket’. Finally, Mick tells us what Santa might be bringing him for Christmas.
In this episode we are lucky to have cryptocurrency proponent and trader Jay Smith on the show. We start off by talking about how he got introduced to cryptocurrencies and trading, highlighting what trading actually is, and the two different schools of thought (fundamental vs. technical analysis). From here we move on to chat about how innovations such as Bitcoin are changing the way we view money/bank, the underlying technologies that make it possible (Blockchain), and the game-theory/incentives behind it for each participant to continue ‘playing the game’. Conversation then moves on to touch upon alternative cryptocurrencies (alt-coins) and the different use-cases/advancements they are making in the space. Finally, we highlight Bitcoins scaling dilemma, how all routes seem to effect decentralisation in some shape or form, and how he stores his private keys.
In this week’s episode Edd and Mick catch-up after another long hiatus (sorry about that). We start off by discussing principles mentioned in the Clean Coder book, gaining confidence in code by way of tests, and Elon Musk’s dream of putting a person on Mars. Leading on from this, Edd talks about his continued venture into the internals of Bitcoin, Hardware wallets, ASIC mining USB sticks and Merkle Trees. We then highlight MyBuilder’s recent switch from dedicated servers to the AWS stack, highlighting the pros n’ cons of both approaches and some gotcha’s encountered along the way. Finally, we mention some security audit and monitoring tools that have proven useful for keeping an eye on the (ever increasing) servers present in a typical setup.
After a month ‘off the airwaves’, Mick and Edd are back to delve into several topics that have been keeping them interested. We start off by going down the Cryptocurrency rabbit-hole, highlighting the internal technologies that make up Bitcoin and its practical use-cases. Edd’s ramblings touch upon Satoshi, Cypherpunks, Merkle trees, Consensus algorithms, Hard forks, Segregated witness, Mining, Peta-hashes and much more… Once Edd (finally) lets Mick talk, we move on to chat about a book Mick is reading on Scrum, and question some different Agile practises. Finally, we ask the burning question ‘What is the Internet, Anyway?’.
In this weeks episode we catch up with Joe Watkins discussing all things PHP. We start off the discussion with how his role as release-manager is going for PHP 7.1, highlighting how Security bugs are defined and handled within internals. Following this we chat about several RFC’s that are under-discussion (Retry Keyword, UUID) and accepted (Libsodium, Object Typehint) for the next release. Finally, we mention a recent small extension Joe has been working on to provide user verified types within the language.
In this weeks episode we discuss the Varnish ‘HTTP accelerator’ with Mattias Geniar. We start off the show with the problem Varnish is trying to solve, how it decides to cache content and the power within its’ request/response life-cycle. We then move on to highlight testing strategies, tools to gain insight into your Varnish instance and cache invalidation options (Purging vs. Banning). Finally, we touch upon Edge Side Includes, Mattias’s own podcast and his new DNS Spy product.
In this weeks episode we start off by discussing Edd’s recent Server build, touching upon the hardware specifications, OS/ZFS-pool choices and monitoring configuration. We then move on to highlight the value in splitting up computational intensive tasks into queued jobs, defensive programming in JavaScript and handling querying ever increasing data-sets. Finally, we talk about keeping on-top of Software/Dependency upgrades, moving over to platforms such as AWS and Ethereum.
On this weeks show we are joined by Colin Hardy to discuss all things Cyber Security. We start off by explaining what got him interested in this branch of computing, highlight what Cyber Security is, and define some of the common terminology. From here, we move on to discuss how he analyses Malware samples (using Automated, Behavioural and Static means) and the diagnostic tooling present. Finally, we mention some high-profile attacks (Stuxnet, WannaCry), motives behind creating such Malware and how he stays current in this field.
In this weeks episode we are lucky to have Liam McLennan on the show. We start off discussion with his Math background, how he got into programming and how it can be seen as Applied Mathematics. From here we move on to highlight his experiences whilst consulting, what it entailed, and the importance of ‘tact’. This leads us on to look into what drew him to Functional programming, F# and creating Pluralsight courses. Finally, we delve into the different areas of the Nokia Ringtone Composer Emulator from his F# Fundamentals course.
In this weeks episode we are joined by fellow co-host Fraser Hart. We start off by discussing what he has been upto since his last podcast appearance - ranging from completing an Ironman, to promotions at work. From here we highlight how he balances development with his new project managerial role, how his company has started to adopt React/Redux and moving over to Webpack 2. Finally, we delve into the different server stacks we are using, and how the KISS design-principle plays a key-role.
In this weeks episode we are again lucky to be joined by Brian Moses, to continue our discussion on building your own home server. We start off by highlighting what ECC memory is and its’ value in a home server setup. Following this, we chat about looking into the second-hand market for hardware components - as an option to find a good deal. This leads us on to discuss overclocking hardware, threads vs. cores within a CPU and what Hyper-threading actually is. Finally, we mention some different NAS Operating System solutions and Brain’s foray into the world of Quadcopters.
In this weeks episode we start off the podcast with discussion around Timezones, Daylight saving time and how the Year 2038 will be an interesting one. We then move on to highlight the results of our recent PHPStorm Twitter poll, End-to-end encryption and Hot Picks is back! (at least for one show). Finally, we highlight the differences between Software/Hardware video-decoding and some interesting PHP function aliases.
In this weeks episode we are joined by Brian Moses to discuss all things server development. We start off the show by highlighting how he got into computers and what drew him to blogging about DIY NAS builds. From here we touch upon the key areas of consideration when deciding on hardware (Motherboard, CPU, RAM, Storage) for a server. Finally, we discuss the concept of RAID, the FreeNAS operating system and how he performs burn-in testing on recently built systems.
Note: apologies for some of the audio quality during the show.
In this weeks show we follow on from our previous episode’s discussion with Scott Wlaschin. We delve into separating out the client from the behaviour and state, initially highlighting the Batch Command approach. From here, we move on to discuss the Actor Modal, Event Sourcing and Functional Reactive Programming solutions. Finally we touch upon handling the behavioural dependencies, followed by creating an Interpreter and Capability-based implementations.
In this weeks episode we are lucky to be joined by Scott Wlaschin again, to discuss his recent ‘Thirteen ways of looking at a turtle’ talk. We start off discussion highlighting the value of solving a known problem in many different ways and the inspiration behind the talk. This leads us on to chat about the Object-oriented and Abstract Mutable/Immutable Data Model solutions, mentioning each ones merits as a way to solve the problem. We then move on to highlight the State, Either and Async Monad solutions, and how they aid in function composition of different ‘shapes’. Finally, we mention how good code should be boring, the balance of the abstract vs. concrete and transparency in code.
In this weeks episode we start off discussion with experiences handling online payments, CRM export integration and highlight how PHPStorm can be a great SQL editor. We then move on to mention a service that allows you to easily manage browser polyfills, and Edd chats about his experience currently making a Nokia ringtone composer web application. Finally, we touch upon handling transactional email, depending on third-party services and using Continuation-passing style within JavaScript.
In this weeks episode we are joined by the creator of Zencastr, Josh Nielsen. We start off discussion with how he got into programming and being hired as a ‘webmaster’ at the University he attended. From here, we move on to highlight the problem Zencastr is trying to solve, delving into some of the technical aspects and corners that were cut to focus on the primary solution. Finally, we mention the testing strategy in place, how it is changing as the product stabilises and what features are next in the pipeline.
In this weeks episode we chat to good friend of the show Joe Watkins. We start off discussion with his recent work on creating a compute-node, dual WAN setup and accepted PHP Serbia talk on contributing to PHP without being a ‘C wizard’. From here we move on to mention some of the areas (bug tracking system and QA) that could be improved with the help of new contributors within the PHP internals ecosystem. Finally, we highlight several recently proposed RFCs, his opinions on them and some work he is doing on a future RFC.
In this weeks episode we are lucky to have Steven Proctor back on the show. We start off discussion by congratulating him on 82 episodes of Functional Geekery, and the commitment it takes to do a podcast and not just ‘podfade’. From here we move on to highlight any commonalities he notices with people getting into FP, how he stays on-top of the latest advancements and how he finds the guests he wishes to speak to. This leads us on to compare learning functional concepts within a language you already know vs. in a totally different lanaguge which is rooted in the principles. Finally, we chat about interesting projects that are on his radar and advice that he has for people who wish to begin exploring FP.
In this weeks show we are joined by Phil Sturgeon to discuss all things API development. We start off by mentioning Phil’s new job at WeWork, Startup life/culture and switching between different development philosophies. We move on to highlight how he got into API development, the reasons behind writing the book “Build APIs You Won’t Hate” and a future video-series he has in the pipeline. This leads on to discuss common misconceptions of REST and RPC, API tooling available and the different data-formats present. Finally, we mention the importance of good error-handling within an API (no 200 responses!) and some of the bad-stories he has heard/encountered on the topic.
Following on from our previous look at the Query planner - we are joined again by Bruce Momjian to extend this exploration into looking how Postgres manages concurrency. We start off by discussing some of the challenges and workarounds used in the past to handle concurrent access, particularly in the eyes of a database administrator. We then highlight the concept of MVCC, how it works from a high-level, how Postgres implements it and the clean-up considerations that are present. Finally, we mention how Postgres stores data in page-form, how projects such as pg_compact work to regain space and what the fill-factor is.
In this weeks episode we are joined by Jimmy Burrell and Scott Wlaschin to discuss all things functional. We start off the show highlighting how Scott got into programming, the reasons why he is a big fan of Smalltalk, what he means by ‘Enterprise OO’ and being a Humanistic programmer. From here we discuss how he got into FP, how the paradigm came to being, what FP is to Scott and why you should consider it. Finally, we mention the differences between types in FP over langauges such as C, the railway track metaphor he uses to help explain FP concepts and architectural patterns that are more or less suited to FP.
In this weeks episode we have a long overdue catch-up with Lew. We start off by discussing what he has been upto, and a certain four-legged addition to his family. From here we move on to chat about working on a product vs. working in an agency setting, picking your battles when refactoring and not being scared to make mistakes. Finally, we highlight how Edd has recently used personal Homebrew taps, using Android simulators for testing and Lew’s experience with Vue.js.
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.
In this weeks two developer podcast, we start off discussion with Edd’s recent holiday to America - including experiences driving, Carousel and Instagram. We then move on to chat about ‘Space Beer Cave’, Fraser’s recently released game for the Android platform. Built using Phaser and CocoonJS we touch upon how the game was initially built in a single day, along with the process of getting it uploaded to the Google Play store. Finally, we talk about how Fraser is able to balance freelance and full-time employment, along with handy material that Troy Hunt has released in regard to web security.
With the release of Space Beer Cave, the podcast’s first competition has been devised. Simply download the game from the Google Play store (sorry iOS users at this time), play and then tweet/email a screen-grab of your highest score. The competition ends on the 12th June 2015 18:00:00 GMT with the winner receiving their very own Three Devs and a Maybe t-shirt!
Originally recorded early February but only now being released (blame Edd), we are lucky to have Joe Watkins on the show again. The show starts off with payment gateway woes, Joey Essex ‘bants’ and Joe’s experience researching into Vitess. We then discuss how Joe works on improving a large, mature code-base in his day job - enjoying brown-field projects as the code has already been proven in production. Finally, we bring up the topic of working remote, discussing the pros n’ cons with two very different viewpoints. This includes, highlighting how important collaboration tools are and remote working loneliness.
Hey folks! Sod’s law but just as we were getting into our stride recording this week the technology failed us! Thankfully we managed to ramble a sufficient amount before this happened.
Finally the 4 of us all were online to together so lot’s to catch up on i.e. Mike’s fascinating computer animation module, Fraser’s React.JS workshop among other usual ramblings. It also looks like we may have Adam from the popular web podcast ‘Full Stack Radio’ joining us soon which we all look forward to.
So without further ado, enjoy the rest and thanks for listening as well as your feedback.
This episode we are fortunate enough to have Phil Sturgeon back on the show. Originally recorded on the 11th Feb and only now being released (blame Edd), the show starts of with a comparison between Phil and Fraser’s snowboarding injuries. We then move on to discuss standing desks, Sunshine PHP, American weather, and conference experiences. Following this DDD (Development Driven Development…) is touched upon, along with a look at the current stack Phil is using at work. Finally we chat about the ‘attack-of-the-clone’ packages Phil has noticed around the PHP community (ultra-tiny-small-restful frameworks etc.) and how far the ‘The League of Extraordinary Packages’ has grown.
Hey folks, Edd, Lew and Fraser are back this evening for a good ol’ web/anything else catchup.
We begin with our usual catch up, Lew discusses his CMS migration to Laravel and also the discussion to make it more API based. Edd then talks about some new caching mechanisms he has been using recently and Fraser rounds off by discussing the difficulties with making a gaming app and how tough it is working with the infinite platforms available. We also announce some exciting news regarding a live show coming up this Autumn!
Following that, we discuss the difficult CMS ‘problem’ and our own experiences with this before Edd finally rounds off with a mathematical dilemma.
If this doesn’t whet your appetite, nothing will. Enjoy :-)
We’re back folks. It’s been a few weeks since we last recorded and thanks to you all that enquired as to ‘where we were?’
Lew, Mike and Edd got together this week for a long overdue catch up. Turns out, we’ve all been up to quite a lot. Mike is winding down towards the end of his University course, Lew has been a learning machine during quieter times at work and Edd has been extremely busy with mainly Swift projects. We chat about the various things we have been doing and things ahead. Lew then discusses his move over to using the Laravel framework and his reasons for moving away from his own framework. Mike discusses his experiences at the PHP Conference, and Edd then finishes by discussing his dabbles with ES6.
Anyway, enough spoilers… give it a listen ;-)
This week we are very lucky to have Edd’s work college and good friend Keyvan Akbary on the show. We start off discussing how Google Maps lied to him on his train journey down from London to the ‘Garden of England’ Kent. This moves us on to talk about the exciting new greenfield project he is currently working on - following a DDD approach, comprehensive test suite and TDD. After this we back track a few steps and chat about how he got into computing and subsequently programming - through a high school web-page and friendly competition with his brother. Following this we delve into his University experience and how he felt happier in a work setting, which can be seen by the great experience he has been able to gain in such a short space of time. Finally, we discuss his experiences with his own start-up, the current book he is helping write and interesting technologies that currently appeal to him.
With Mick and Fraser off conquering a half-marathon, Edd n’ Lew decide to instead stay inside and do a little lite gaming, followed by a podcast. Discussion starts off with recapping Lew’s Photoshop exploration and how it is good as a developer to know what is graphically possible. We then move on to discuss large Symfony 2 project architectures, creating agnostic packages, and not tying yourself into solving every problem with the selected frameworks patterns. This leads us to touch upon some functional JavaScript concepts and how online environments such as JSBin rock! Finally, we wrap up the show with a look into removing personal data from Git commits and how valuable Gists are.
This week we have a three developer podcast with discussion on a host of topics. We kick off with how Fraser has enjoyed building his first bonus slot game, written entirely in JavaScript and HTML5. Preprocessors are a huge part of the JavaScript ecosystem at this time, with so many to choose from we discuss a couple of the more popular ones. This leads on to Photoshop discussion, ReactJS, the cool features present in ES6 and how you can use them today with transpilers. Following this we move on to the SOLID principles, the overuse of inheritance, technical debt and the concept of Over-DRY vs. Software Value. This then takes us on to a strange ‘rubber duck’ example Edd conjured up to help try and explain the Liskov substitution and Interface segregation principles. Finally, we discuss Edd’s media server setup and how he has got it to a staged that he is finally happy with it.
This week we are lucky to be joined by Joe Watkins, for a general catch-up on a host of PHP-related topics. We start the show off talking about his newly created blog and what drew him to start writing. Following this, we touch upon his first proposed talk on ‘Parallel PHP’ - hoping to resolve some of the confusion around concurrent terminology and patterns. We then mention his experience looking at YouTube Vitess (for MySQL scaling), and the pros and cons of the team deciding to use Go. His work on strict parameter type-hints is then discussed, along with how the idea has changed over time to be a little less strict. We then highlight the awesome work that Nikic has done for the PHP community, along with his most recent article on the improvements made to PHP’s hash-table implementation. PHP 7 and the proposed 5.7 release are then touched upon, followed by the speedy Unicode String implementation. Finally, we discuss the common perception of fear around compiling PHP from source, along with the differences between static and shared libraries.
It is the first show of the new year! In this weeks episode we first reflect on how our holiday breaks went, and what happened to Edd’s face?! Fraser’s move up to Greenwich is next discussed, including how useful the taxi app ‘Uber’ is. We then move on to talk about Mick’s experiences compiling Apache and PHP from source, along with CodeIgniter’s decision to maintain 5.2 support. This leads on to conversation about the upcoming PHP UK Conference, along with tuning queries for the database query planner. Finally, we highlight the differences between Apache and nginx, along with their use of PHP-FPM.
In this weeks episode Mick and Edd reflect on their busy years. We first discuss how work has wrapped up for the new year, and how subtle design changes result in huge benefits. Following this, we compare our personal experiences with product and agency work - chatting about the different programming design mindsets and work-flows used in each case. This leads on to the well-timed appreciation for the work of Martin Fowler, Uncle Bob and Greg Young - inc. valuable tests, the importance of a name and there not being a single ‘silver bullet’ to solving a problem. Finally, we wrap up with what we both would like to learn this upcoming year and Edd’s experiences building a mega PC for a friend.
It is two days before Christmas but that will not stop us from recording a new episode. This week we discuss Frasers gambling hot-streak at Ascot, Micks move and how horrible Martinis are. We then move on to how Fraser is getting on in his new job up in London and Micks University presentation on Fuzzy Logic. This leads us on to how ‘unrandom’ humans are, and professional Rock-Paper-Scissors tournaments. Finally, Edd brings up some interesting talks by Greg Young (on EventStore) and Rich Hickey (on software design). Have a great Christmas everyone and thanks for your loyal listenership!
In our 51st podcast we temporarily revert to a midweek recording of the show. This essentially means we were all a bit tired and delirious, leading to some fantastic randomness, none more than Lew’s ‘different’ introduction to the show. We will let you be judges of that! Following our usual discussion of how things are panning out in our working week, we then move on to discuss some of the interesting security issues cropping up on Michael’s university course. Also, Fraser has landed an exciting new job in London, Lew has found front-end dependency bliss with Bower and Edd is doing some exciting stuff at work too. We also talk about asset file compression/concatenation and issues we’ve encountered with those too. So… plenty to discuss, in fact too much to cram in to our usual hour so we will continue the theme next time. Enjoy folks, and as ever, thanks for listening and for your feedback.
This week we celebrate the 50th episode of the podcast in style, by… not even remembering it is the 50th episode till half way through (whoops). We start off discussion with our differing views on working from home, web unicorns and running shoes. Leading on from this, we bring up a couple of news topics that have been making the rounds in the PHP world recently - along with a proposed Unix command-line series that Mick is keen to do. We then move on to some of the great feedback we have received from you guys this past week, and somehow this leads to Edd rambling on about the Unix philosophy/application composition again. Finally, we discuss the state of CodeIgniter 3, how Git works under-the-hood and Objective-C/Swift’s memory management model.
P.S. very sorry for the noticeable audio issues throughout the episode, Edd tried his best to fix them - but unfortunately he is no audio ninja.
This week we have yet another episode with the full podcast crew. Discussion starts off with the journey down to help Michael in his new house, along with the must buy book ‘Boundaries in Dating’. We then switch topics onto how Edd is getting on using Swift, followed by the benefits of Semantic Versioning and Promises. Responsive design then gets a mention - as we look into how the Guardian were able to decrease their responsive payload sizes. Finally, we finish off with our thoughts on OSX Yosemite, and how you can use tools like Homebrew, Cask and Ninite (for Windows) to ease clean-installs.
Two weeks in the making, we are finally back with another podcast instalment. This week we touch upon the Unix philosophy, client drama, and shiny new MacBook Pros. We then move on to discuss the security concerns that have arisen from the introduction of contactless payment systems. Leading on from this we talk about the YubiKey and how it can be used to provide two-factor authentication, for services such as LastPass. Finally, we close with how ‘tombstoning’ your code trumps the dreaded commenting out everytime.
This week we are lucky to have Frank de Jonge (of Flysystem fame) on the show. Discussion starts off with an update on the latest Snapchat security vulnerability, and if there is any real point in the service to begin with. We then move on to chat about how Frank got into software development and his method for handling freelance work, by way of meeting his own expectations. This leads on to talk about Flysystem, how the package came about and its’ addition to ‘The League of Extraordinary Packages’. Finally, we touch upon the PHP community in Amsterdam and the great times had at Laracon Europe this year.
This week we start off the discussion with our bad pronunciation of PHP libraries. We then move on to highlight the stress of wrapping up freelance projects - with clients constantly requesting changes (mission creep). Finally, we chat about Google Web Designer and the new Alan Turing movie (The Imitation Game).
This week we are lucky to have Sachin Ishmael on the show, who is currently on a work-placement year at ExtraDigital - studying for a BSc ‘Multimedia Technology and Design’ at the University of Kent. Discussion starts off with how much Edd enjoyed his first conference experience (SymfonyLive London), followed by Michael’s decision to lean towards using Data URIs instead of sprites (reducing HTTP requests). We then move on to chat with Sachin about what it is like to be a student in 2014, and his reasoning behind going to University, inspite of the hefty fees. This leads us to reminisce on our own University experiences and the reasons behind choosing the degree’s we did. Finally, we touch upon what drew him to multimedia, and how throughout the course he has surprisingly started to enjoy web development.
With Lewis back for this weeks show we have the first full-house in sometime, this sparks conversation on what he has got upto since his last appearance. Discussion starts with Fraser’s and Edd’s woes when trying to handle responsive email design - and how the relevant testing is somehow more painful than the dreaded ‘IE’. We then move on to discuss the latest release of PHPStorm, Swift and how the Clean Coders video series helps to refine our development skills. Finally, we bring up the topic of task managers and how most of the hosts are split between using Trello and Basecamp.
Being without a guest this episode, gave us the excuse to ramble on about many different topics that have been on our minds for the past couple of weeks. Starting off with Michael’s experience using WebSockets and Fraser’s fun with setting up a sound Gulp workflow, we move on to discuss the complications rebasing in Git can get you in. Following this, Edd rambles on about the differences between the ‘Active Record’ and ‘Data Mapper’ object-persistence design patterns - along with an interesting insight he found in-regard to TDD. Finally, we discuss the Apple keynote from last week and how we are all pretty much sold on the Apple Watch.
This week we are lucky to be joined by Guy Routledge to discuss all things CSS Preprocessor. Starting off with a brief discussion on his journey into developing for the web, we move onto how he gets business working freelance. Following this we bring up the topic of CSS Preprocessors - what they are, and differences that can be seen in the alternatives available (Sass, Less, Stylus). Finally we wrap up the show with discussion on BEM, CSS ‘Level 4’ specifications and his experience developing the screencast ‘A to Z CSS’.
This week we are very lucky to have Beau Simensen on the show to discuss all things Stack, Sculpin and podcasting. We start off the discussion with how (new dad) Michael is getting on, and if knowing how to code helps at all when having a baby. Fraser on the other hand has had an eventful weekend cycling to France (for fun) and began work on a new project in C#. Following on from this we touch upon how Beau got into programming, and his progression through Perl to PHP. We then move on to how Stack and Sculpin came to being, and the problems they are each trying to solve. Finally we talk about an upcoming Symfony Live event in London that he will be presenting at (on Stack), and Edd will be attending.
In this weeks show we are very lucky to have Joe Watkins on again to discuss all things PHP 7. Starting off with the decisions behind calling the next release 7, we delve into the reasons for 6 being abandoned. Moving on from this we look into what PHP 7 currently has scheduled to offer, including the PHPNG patch, an AST and maybe Joe’s own Unicode String class. We then discuss how a PHP script is internally lexed, parsed/compiled and cached, - including how a JIT would speed up certain use-cases. Finally we touch upon the much requested String type hinting and how a solution similar to Java’s could be implemented with minimal hassle.
In this weeks pre-recorded show we introduce the Java and C# languages, discussing how the two relate and diverge in design. Starting off with a brief history on the two languages, we move on to the different setup environments and IDE options available to you. Leading on from this we touch upon some of the technical differences, such as - Value/Reference Types, Unified Type System, Exception Handling, Type Inference, LINQ and Extension Methods. Finally, Edd goes on a little ASP.NET tagerent and a brief delve into the crazy world of the ‘java.util’ package.
This week we start our chat off with the myth of just simply ‘reskinning’ a website, along with the dreaded !important in CSS. Following this, as we love quizzes so much, we decided to dedicate a full show to one. In this weeks quiz we touch upon many areas of PHP, JavaScript, CSS and random computer/programming history. We also now have t-shirts on sale, available via the first link in the show-notes (why don’t you treat yourself).
In this weeks show we are discussing all things SPL (Standard PHP Library), used to solve commonly found problems in an OO-PHP manner. After a brief tangent on what each cast member uses for placeholder text/images, we touch upon the key reasons for SPL’s development. Following this we highlight a few of the many data-structures (fixed-array, doubly linked-list) and interfaces (countable) available to you. Finally, we wrap up the show with the regular quiz, which you’ve probably guessed it, is topically about the Standard PHP Library.
This week we have good friend of the show Justin DeLucia on to help host our first dedicated Q&A episode. Not only that, but Fraser is back! along with some crazy adventures that he discusses since his last time on the show. We have been fortunate to receive many questions throughout the past couple of weeks, and thought it would be good to release the answers as a dedicated show. Topics discussed include, breaking into the industry, the PDO vs. Mysqli debate, bespoke vs. off-the-shelf CMS debate and what to consider when building a Web API.
This week we are lucky to have Simon Holywell on the show to talk all things Functional Programming. Initially starting off with a concrete definition of Functional Programming, we move on to a brief history of the paradigm and immutability. Following this we explain recursion (and tail-recursion), along with closures and higher-order functions. From this base we are able to then talk about the different languages available to you which cater towards the functional mindset (i.e. Haskell). We then set our sights on the PHP language and what/wish it had to offer when exploring the functional paradigm. Finally, we mention his upcoming book, along with experiences presenting at user-group meet-ups.
This week we are very lucky to have James Watts, a core member of the CakePHP project on the show. Initially starting off with his journey into programming, we move on to talk about the differences we find between junior and senior developers. We then touch upon his previous start-up experience and how that resulted in him thinking more about the product as a whole. CakePHP has been around for almost 10 years now, we discuss how he got into the project - along with the frameworks key goals. We then move on to highlight some of the key differences/features you will find in the next major release (3.0). Finally, we discuss his upcoming book, and his experiences with organising a large open-source community event.
This week we are very lucky to have the creator of Laravel, Taylor Otwell on the show. Starting off with his journey into the world of programming (through .NET), we move on to discuss how Laravel came to being. We then touch upon our experiences experimenting with different programming stacks, and what features of C# he would like to see introduced into PHP. Finally, we ask Taylor what resources he would recommend to someone just starting out in the industry.
This week we are lucky to have Kris Jeary on the show to discuss all things design. Starting off with how he got introduced to the world of web design, we move on to discuss the process he uses to create websites. We then touch upon where he gets inspiration from, and how the emergence of responsive and SPA ideologies has changed the way we think about the web. Finally, we wrap up the show with some good advice to anyone looking into getting into web design.
This episode we are very lucky to be joined by Dayle Rees, to discuss all things PHP, Laravel and Colour Schemes. Starting off conversation with how he got into PHP, we move on to his initial introduction to the Laravel framework - and his involvement during the development of versions 3 and 4. From there we touch upon his very popular text-editor colour schemes project, and how the Code Happy/Bright books came about. Finally, we discuss his new book ‘PHPandas’ which is currently being written, targeted at absolute beginners to software development.
In this episode we introduce the very important topic of software testing. Starting off with why you should consider the automated testing route, we move on to discuss the different types of testing available. Some of the topics discussed include Quality Assurance, TDD/BDD, Unit Testing, Integration Testing, Functional Testing and Acceptance Testing.
This episode we are joined by Paul Bowden to talk all things Linux. We start of with the Linux vs. GNU/Linux vs. GNU/Linux/X debate, and layout what an Linux Operating System actually is composed of. With this foundation in place we move on to discuss the different types of distributions available, along with a host of Window Managers and Desktop Environments. Finally, we wrap up the show with some good advice to budding Linux converts, along with a brief detour into two popular ‘hardcore’ distributions (Gentoo and Arch).
This week we are lucky to have the one n’ only Phil Sturgeon on the show. Starting off conversation with how he got into programming, we move on to his time using and contributing to the CodeIngiter and FuelPHP projects. This leads us on to discuss the current status of CodeIgniter 3.0 and his experiences with porting PyroCMS to Laravel. Among other things we then touch upon the ‘Wordpress positive feedback loop’, the PHP-FIG (Framework Interop Group) and the PHP-RFC (Request for Comments) process. We wrap up the show with some sound and interesting advice to any budding/new developer.
In this weeks show we decided to have a good ramble about a couple of topics that have cropped us this week. Ranging from freelance experiences, cheese-based Lorem Ipsum text, and famous Albert Einstein quotes. By the end we start to discuss our personal software deployment strategies, briefly touching on Docker, which will be the topic of next weeks show.
This week we are very lucky to have Joe Watkins from pthreads and PHPDBG fame on the podcast. Starting off discussion with the ‘PHP Next Generation’ drama, we move on to wrap-up our thoughts on the ‘Is TDD dead’ set of Google Hangouts. The topic then shifts onto our guest and how he got into programming and PHP - with the creation of pthreads and PHPDBG projects discussed. Finally, we finish off the podcast with the regular quiz.
This week we are very lucky to have Jacques Woodcock and Ben Ramsey from the virtPHP project on the podcast. Similar in nature to Python’s ‘virtualenv’, virtPHP is a tool for creating and managing multiple isolated PHP environments on a single machine. Currently command-line support on *nix based-systems is complete, however, during the show we touch on the challenges in-regard to SAPI support. We then move on to discuss the interesting paths each took to get into development, followed up finally with the weekly quiz.
Having only just recently been bit by the character encoding issue again, we thought it would be a good time to bring it up on the podcast. Starting from the beginning with ASCII, we move on to discuss how 8-bit compatible machines brought way to the ISO-8859-* standards. This leads us on to Unicode, with the goal to develop a single character-set encoding standard that could support all of the world’s scripts. Finally, we discuss the de-factor character encoding implementation used on the web today ‘UTF-8’, and reasons why this is the case.
This episode we are lucky to have special-guest Lamin Sanneh on the show to discuss all things EmberJS. Looking at the current JavaScript framework landscape, we move on to highlight what makes EmberJS stand-out from the crowd. Finally, we have an ad-hoc quiz which helps highlight PHP function aliases and JavaScript’s ‘this’ context binding.
In this weeks show we introduce error handling, focusing on how exceptions are used. Initially touching on a brief history of exception’s origins, we move on to highlight how languages such as PHP and JavaScript implement them. We round up the chat with a ‘pros and cons’ breakdown and a fun-packed quiz.
In this weeks show we introduce the JavaScript programming language, which now seems to be available everywhere. Initially discussing the prototypal-languages goals, we move on to a brief history lesson - touching on the ECMAScript standard. We then explain how JavaScript uses the DOM and Ajax to create dynamic, client-side applications. Finally, we wrap up with the usual ten question quiz.
In this weeks show we follow up the discussion on CodeIgniter with an introduction to Laravel. Introduced only a few years ago, the framework has been a ‘breath of fresh air’ in the PHP framework landscape. Starting with a brief history of the project and how it has evolved, we move on to highlight key features of the framework that set it apart. One such inclusion is the extensive use of an IoC container, and how Facades cater for an expressive code-base.
In this weeks show we continue our discussion on web application frameworks by delving into CodeIgniter. Though it has had its fair share of bad press over the past couple of years, its mature code-base and ease of getting started can not be denied. Initially exploring what the framework is from a high-level we move on to discuss it’s strengths and weaknesses along with personal experiences. We finally wrap up the show with a CodeIgniter influenced quiz.
This week we introduce web application frameworks into the software development mix. Starting of with what they actually are, we move on to the benefits and useful feature set they provide you.
This week we wrap-up the top ten security risks compiled by OWASP, with discussion on topics including CSRF (Cross Site Request Forgery) and Known Component Vulnerabilities. Also included this week is a brief introduction to Hack and are thoughts on the programming language Go.
With another two man crew this week we decided to make a start our discussion on all things Web Security. Directed at PHP developers, we go over the top five security risks compiled by OWASP (The Open Web Application Security Project).
This week we are lucky to have special guest and good friend of the show Justin DeLucia on to discuss all things web design. Starting off with background discussion on how he got into the industry, we move on to how designers and developers work (and should work) together. Finally, we wrap up with our longest quiz yet, which undoubtedly went off in many random tangents.
With only a two man crew this week we decided to have a little ramble about Composer and the Command Line. Initially discussing the benefits of Composer over alternatives (i.e. PEAR), we move onto some of the real-world issues that can arise from ‘depending’ on it. We then segue into discussing the Command Line and some of the key points new users should now about.
This week we discuss the important topic of learning how to effectively use the PHP documentation. Although easily neglected for other resources (i.e. StackOverflow), the official PHP documentation is a great place to learn about new functions and how they can be used. Finally, we touch on some accompanying third-party documentation tools we use on a daily basis.
This week we discuss the popular MVC (Model-View-Controller) design pattern and how it is used in web application development today. We start with a brief history lesson and introduction to design patterns, then move on to a quiz which highlights some of variants that have been created.
In this weeks show we introduce CSS to the web-development party. Starting off with a brief history lesson, we transition into highlighting why it is useful and the different types of styling options available. Finally, we put to rest the confusion between the different versions.
This week we wrap up the discussion on HTML, highlighting useful tools that we have encountered and incorporate into our work-flow. We then move on to briefly talk about considerations that should be addressed when designing and implementing website navigation.
Sadly we are one host down this week with Lewis hard are work, so we decided to postpone part two of the HTML discussion till next week. In the meantime however, we divert are attention to introducing the Object-oriented programming paradigm. We discuss its’ advantages, along with concepts such as Objects, Classes, Data Encapsulation, Inheritance and Polymorphism.
This week we decided to do an episode on good ol’ HTML. There are many good resources online for learning the language, so instead we decided to discuss our personal experiences. Along with this we reflect on browser support issues and how to help alleviate these problems.
Following our discussion last week, we received a very cool email from a listener highlighting freelance work. In this weeks podcast we have a chat about our freelance experiences and how we find projects to take on. Following this we touch on things to look out for and how to juggle your day job and outside work.
With all the recent discussion in the PHP community we decided it would be a good time to give some grounded advice to new developers. When you do decide to bite the bullet and begin learning web-development/PHP you may quickly be overwhelmed with talk of frameworks, third-party code and dependencies. In this podcast we give our take on what is best to learn and when, and how we each personally went about doing it.
In the podcast this week we discuss the important topic of text editors. You will be using one daily if you plan to get serious about your programing, so it pays to be aware of what is out there. We first highlight the difference between text and source editors, and then name a couple of examples we have used in the past. Finally, we briefly discuss IDE’s and the merits of using such an application when programming.
Second part of our discussion on Web Hosting options and what to look out for. We then move on to talk about Domains, DNS and the different types of record types (A, CNAME etc.).
1st part of our section on web hosting. In this episode we cover an essential part of web development, choosing a web hosting solution that is right for you.
This episode explores getting started, including, creating a local environment, and explores some very basic programming logic, in particular PHP logic. We touch on collections/arrays, data types, looping techniques.
This episode introduces listeners to the people hosting the podcast. It also touches on some very basic topics such as, what is needed to get in to web development, what experience is required, what will it cost, what will I need to learn. This is for absolute beginners, no knowledge at all of web development is required.