Disfruta de Premium PARA SIEMPRE. ¡Ahora con un 20% de dto! ¡LO QUIERO!

Podcast
The Static Void Podcast
29
1
For developers, by developers
Messaging in Distributed Systems - What's the Deal?
Episode in
The Static Void Podcast
Chris, Jess, and Todd chat about enterprise messaging patterns. Is it a good practice to put a message bus or a queue in between your web server and your middle tier services? Can message buses be overkill? What's the best way for your loosely-coupled containerized services to communicate with one another? Did Todd actually say that there's some benefits to building a monolith?
We asked all these questions, but you've got to listen to see how many of them we actually answered... or how many answers we actually got right.
01:12:45
Going beyond NuGet.org by creating your own packages
Episode in
The Static Void Podcast
Jess and Chris chat about not just using NuGet to download Microsoft's and other Open Source libraries from NuGet.org, but creating your own custom NuGet packages to help version and distribute your own components, without ever leaving your firewall!
Links
Microsoft: Creating and Publishing a NuGet Package
Microsoft: Creating NuGet Symbol Packages
Microsoft: .nuspec File Reference
SemVer.org: Semantic Versioning guide
SymbolSource.org: The public symbol server
MyGet.org: Host your own (private or public) NuGet feed
ProGet NuGet feed source
JFrog Artifactory: Artifact repository with NuGet support
01:18:32
Real-World Git
Episode in
The Static Void Podcast
Todd, Chris, and Jess chat about using Git in their day-to-day lives. Jess thinks it's the best thing since the CPU, but Todd thinks it's just the shiny new toy that's no better than TFS. Meanwhile, Chris thinks that GitFlow is the most overly-complicated process he's ever seen. What do you think?
Links
Think Like (a) Git
GitHub.com: Understanding GitHub Flow
Vincent Driessen: A successful Git branching model (GitFlow)
Atlassian: Comparing Git Workflows
01:26:00
Developer Productivity: TechBash 2017 Conference Panel
Episode in
The Static Void Podcast
What's the best way for a developer to provide true "value"?
Join our panel of experienced developers as they discuss their patterns, practices, methodologies, frameworks, tips and tricks that help them reach their maximum productivity. Whether it's solving customer problems (usually with code), contributing to or running open source projects, or even curating online content like video training courses, these panelists tell you their secrets of how the "get stuff done."
Panelists
Scott Allen
Stephen Bohlen
Damian Brady
Suz Hinton
Oren Novotny
01:03:49
Real-World DevOps with Andy Schwam
Episode in
The Static Void Podcast
What does "DevOps" really mean when you're not up on stage demoing the latest DevOps product or working at Netflix, Etsy, or Facebook? To find out, we ask Andy Schwam (@schwammy), a development manager, architect, and coder who has lived and breathed the concepts of "DevOps" in the real world... and lived to tell about it.
What's myth and what works? What's hard and what's easy? Andy takes us behind the scenes and tells us what it takes to transform an existing error-prone manual deployment to a highly-reliable, repeatable, and automated process.
01:26:01
Introducing Razor Pages
Episode in
The Static Void Podcast
Razor Pages is a brand new feature in .NET Core 2.0 that brings the Page Model back into .NET Core, providing developers a simple, effective, and above all, easy way to create dynamic web pages without having to get into the details of the Model-View-Controller (MVC) approach.
Or is it?
Join Jess, Todd, and Chris as they try to make sense of that one last .NET Core 2.0 feature that they left out in the last episode, Razor Pages. What exactly is it? Is it actually simple? Is it really easier than using ASP.NET Core MVC?
Show Notes and Related Links
Razor Pages - Official Documentation
Razor Pages - Getting Started with the Preview (Mike's DotNetting)
Razor Pages - Understanding Handler Methods (Mike's DotNetting)
Model-View-Presenter (MVP) Design Pattern
MVC or MVP Pattern - What's the Difference? (Todd's blog post)
01:11:54
.NET Core 2.0: Is it ready?
Episode in
The Static Void Podcast
In anticipation of the up-coming .NET Core 2.0 release (and the preview currently available), Todd, Jess, and Chris offer their answers to some of the frequently asked questions around .NET Core, such as:
Does .NET Core 2.0 have all the namespaces/APIs as .NET 4.6?
Does .NET Core support Visual Basic (VB.NET) yet?
What about SignalR - is that available?
What options do I have when running my ASP.NET Core applications? Do I have to use IIS? What about Docker?
What is .NET Standard (and should I care)?
What's the best IDE to use when building an ASP.NET Core application?
And, of course…
Should I start moving from .NET 4.6 to .NET Core now? Is it ready for prime time?
Links and References
Webinar courtesy of PostSharp: Who needs Visual Studio? A look at .NET Core on Linux
Build 2017 Sessions online
An overview of .NET Core, discussing the approach, features, and goals
Visual Basic in .NET Core announced with .NET Core 2.0 Preview 1
(It's there… search for "Visual Basic is now Supported" on the page)
Visual Studio 2017 Preview
(Includes tooling for Visual Basic in .NET Core and .NET Core 2.0 / ASP.NET Core 2.0)
ASP.NET Core SignalR at Build (video)
ASP.NET Core SignalR Repository
ASP.NET Core Roadmap
Socket.io - Real-Time Web in Node
Anders Hejlsberg: What's New In TypeScript (video)
(This turned out to be a good introduction to TypeScript and how it can help you in different ways, you can choose what you want to adopt)
Kestrel in production (internet facing) and using a reverse proxy
"If you expose your application to the Internet, you must use IIS, Nginx, or Apache as a reverse proxy server."
Matt Watson from Stackify has some plain english on this on the Stackify blog
(Thank you Matt!)
You will need the "ASP.NET Core Module" to run Kestrel behind IIS
Introducing .NET Standard (blog post)
.NET Standard documentation
Visual Studio for Mac
01:13:48
The Twelve-Factor App: How to build modern, cloud-ready web applications
Episode in
The Static Void Podcast
Join Jess, Todd, and Chris as they discuss "The Twelve-Factor App": a set of patterns and practices that are crucial to building modern, scalable, and "cloud-ready" applications.
The 12 Factors will help you build web applications that:
Use declarative formats for setup automation, to minimize time and cost for new developers joining the project;
Have a clean contract with the underlying operating system, offering maximum portability between execution environments;
Are suitable for deployment on modern cloud platforms, obviating the need for servers and systems administration;
Minimize divergence between development and production, enabling continuous deployment for maximum agility;
And can scale up without significant changes to tooling, architecture, or development practices.
Show Links:
The Twelve-Factor App: The site that started it all
Beyond the Twelve-Factor App: (free eBook) The follow-up book that expands on the original 12 Factors and adds some great real-world advice
01:10:59
Visual Studio Code vs. Visual Studio "Classic" -- what's an IDE, anyway?
Episode in
The Static Void Podcast
In this episode, Chris, Todd, and Jess discuss how awesome Visual Studio Code is while Todd defends the relevance of the full-blown Visual Studio "Classic Cadillac" IDE. What's the difference between an "IDE" and the new breed of powerful and extensible "text editors" such as Notepad++, Sublime Text, and now Visual Studio Code. Oh yeah, and Jess gets yet another reason to talk about how great TypeScript is, too.
Show Links
Extending the Visual Studio IDE ("classic Cadillac")
Extending Visual Studio Code
Jess's VS Code NuGet Reverse Package Search extension (Source Code)
55:36
.NET Core RTM - Real World "File > New Project"
Episode in
The Static Void Podcast
Several episodes in to the ".NET Core RTM" series, Jess, Todd, and Chris finally get down to the specifics of how to use .NET Core. Starting with File > New Project all the way down to View Components, they talk about what it's like to actually use ASP.NET Core to develop real web applications.
59:01
.NET Core RTM - Jeff Fritz explains why it could be awesome after all
Episode in
The Static Void Podcast
Jeff Fritz from Microsoft joins Jess, Todd, and Chris to talk about .NET Core and we challenge our discussion of .NET Core RTM in the previous episode. Now that you've heard several sides of the story, what do you think? Let us know at staticvoidpodcast.com!
01:20:00
.NET Core RTM - What is it and what does it mean?
Episode in
The Static Void Podcast
In this episode, Jess, Todd, and Chris talk about the fact that .NET Core (and ASP.NET Core) have been officially released, and contemplate what that means and how it might (or might not) affect .NET developers.
Some links to content discussed in the episode:
.NET Core home page
ASP.NET Core Documentation
.NET Core Documentation
Blog Post: Announcing .NET Core 1.0
Blog Post: Announcing ASP.NET Core 1.0
Blog Post: Announcing Entity Framework Core 1.0
Blog Post: .NET Core RTM Announced at Red Hat Conference
Videos about ASP.NET Core RTM
ASP.NET Community Standup
Conference General Session including announcement
Conference General Session including announcement (Scott Hanselman's presentation)
ASP.NET Core Kestrel: Adventures in building a fast web server - Damian Edwards, David Fowler
ASP.NET Core 1.0 Deep Dive - David Fowler & Damian Edwards
Benchmarks for ASP.NET demonstrating Kestrel performance
Introduction to TechEmpower benchmarks
54:26
The Browser as a Development Platform
Episode in
The Static Void Podcast
In this episode, Jess, Todd, and Chris debate the merits and the suitability of using the browser as an application development platform. From memory management, to the DOM, to deployment, to Todd wishing that Silverlight never died, we touch on a variety of aspects involved in working in the browser.
01:11:01
Code Sprawl with Matt Hornsby
Episode in
The Static Void Podcast
Chris, Todd, and Jess welcome their guest Matt Hornsby to discuss a concept he calls "Code Sprawl" to describe the evolution and decay of software systems over time. Relating the growth and aging of a software project to the growth and decay of urban areas, he draws parallels to identify what goes wrong. He also presents hope that we can learn from urban renewal as well.
About our guest
Matt Hornsby is an experienced principal software engineer who has led teams building Internet scale applications such as healthcare exchanges and retail websites that are among the largest in the world. This led Matt to develop a passion for guiding his teams to build maintainable systems and write quality code.
Related Links
Sprawl Repair Manual
The Design of Everyday Things
The Dunbar Number
Christopher Alexander: A Timeless Way of Building
A warning to last ten thousand years
01:18:09
WCF vs. Web API
Episode in
The Static Void Podcast
Microsoft offers two frameworks that both allow you to create fully-functional web services and HTTP-based "web APIs". Which one should you choose?
Join Jess, Todd, and Chris as they debate the merits and "proper" usage of the two most popular Microsoft frameworks for creating web-based services: WCF and Web API.
Show Links
ASP.NET Web API
Microsoft WCF (Windows Communication Foundation)
54:33
The Best C# 6 Features
Episode in
The Static Void Podcast
Chris, Todd, and Jess discuss the cool new features available in C# 6. Some will save you keystrokes, some may save you bugs, and some... well, some you may never actually use (but why not find out about them anyway?).
Show Links
New language features in C# 6 (Rosyln GitHub wiki)
Roslyn GitHub site
Essential TypeScript by Jess Chadwick
Steve Michelotti’s Code/Slides on C# 6
57:16
BUILD 2016 Response Show
Episode in
The Static Void Podcast
In this episode, Jess, Chris, and Todd share their thoughts on the announcements and presentations that happened at Microsoft's BUILD 2016 developer conference.
The biggest question is: how much of this is (or will be) actually relevant to us?
01:12:35
Automated Testing for Developers
Episode in
The Static Void Podcast
In this episode, Todd, Jess, and Chris chat about automating developer testing. Some call it "TDD", some call it "BDD", but we just call it a good topic for a show! Join us as we talk about our varying experiences with creating, modifying, getting rid of, or even completely avoiding automated unit tests and how it's affected us.
In this episode, we mention the following great resources:
Working Effectively with Legacy Code by Michael Feathers
FitNesse - wiki and acceptance testing framework
SpecFlow - BDD testing framework
And, here are some other great resources that we didn't happen to mention but you should check out anyway!
Test-Driven Development on Wikipedia (yes, it's a great resource!)
NUnit - .NET unit testing framework
xUnit - .NET unit testing framework
Selenium - Browser automation (acceptance testing) framework
Nightwatch.js - Write your Selenium tests in JavaScript (Node.JS) (works great for any web application - even if it's written in .NET!)
Learning TDD with Katas
01:13:47
.NET Core and ASP.NET Core 1.0
Episode in
The Static Void Podcast
Join Todd, Chris, and Jess as they wade through the waters of the "new" (but not really new) Microsoft frameworks, .NET Core 1.0 and ASP.NET Core 1.0. What were the motivations for the name change? Was it a good move? What the heck is .NET Core and ASP.NET Core, anyway?
01:02:45
War Stories
Episode in
The Static Void Podcast
In this episode, Todd, Chris, and Jess embrace the holiday spirit and share the stories that have molded them into the hardened code slingers they are today. Did Chris actually meet the real, live Batman while on a job in the middle of the night in Disneyland? Will Jess ever actually get fired - or even scolded - for deleting production databases and bringing production websites to a grinding halt? Why does Todd carry around 4 laptop power adapters to this day? Listen to our stories and decide for yourself.
If you enjoy the show, please let us know by leaving a comment on iTunes or on our website: http://www.staticvoidpodcast.com. We're dying to hear what you think!
48:04
You may also like View more
Hablando Crypto
¿Te interesan las criptomonedas? A nosotros también. Somos Óscar y Cristian. Después de más de 5 años jugueteando con las criptomonedas os explicamos nuestras historias. También hablamos sobre como vemos el crypto-mundo y hacia donde creemos que irá. Updated
Loop Infinito (by Xataka)
Loop Infinito es un podcast diario de Xataka presentado por Javier Lacort.
Un nuevo episodio cada día de lunes a viernes que analiza la actualidad tecnológica dando contexto y perspectiva.. Updated
monos estocásticos
monos estocásticos es un podcast sobre inteligencia artificial presentado por Antonio Ortiz (@antonello) y Matías S. Zavia (@matiass).
Sacamos un episodio nuevo cada jueves. Puedes seguirnos en YouTube, LinkedIn y X. Más enlaces en cuonda.com/monos-estocasticos/links
Hacemos todo lo que los monos estocásticos saben hacer: coser secuencias de formas lingüísticas que hemos observado en nuestros vastos datos de entrenamiento según la información probabilística de cómo se combinan. Updated



