Flipping The Bozo Bit

Keith and Christoph discuss bouncing from implementation details to business goals. Download MP3

Keith and Christoph discuss the “fire” of what matters in software development vs the “shadow” of everything else. Download MP3

Keith and Christoph discuss what “flexibility” might mean for an ongoing, evolving architecture. Download MP3

Christoph and Keith explore the intersection between the technological bedrock we take as given when we develop software systems, such as operating systems, TCP/IP networks, files, automatic memory management (and maybe even HTTP), and the free floating ideas we have before we ever write a line of code. Say ‘technological bedrock’ represents constraints (or the reality) you can’t change, and ideas represent imaginitive worlds you want to bring into being. If that’s the case, then programming languages become the means by which you move from imagination to reality. They’re artistic materials: the raw stuff out of which a representation is made. If so, why do language developers (and perhaps more earnestly, language users) insist on hardening languages to a sub-set of possibilities? This language requires built-in unit tests, that one doesn’t. The one over there insists that everything is an object, while this one insists that everything is a value. Finally, we have a langu

In our last episode, we took as our starting point the notion that Scrum and/or Agile Software Development is more about how to manage tasks than about how to design software, both for quality, and for the humans who need to maintain and extend it. We explored ways of getting design into the process as much as possible. In this episode, we continue the theme by starting with the notion that Scrum/Agile, again, for all its success as a task management, estimation and communication strategy, has nothing to say about building and maintaining a great team. You might find yourself joining a team successfully leveraging Scrum for all its worth yet be at a loss as to how you can contribute. It’s not that you don’t understand the process. That part’s easy. It’s that, well, there’s the software, the ecosystem, the politics, the personalities, the design and the architecture. The technical debt. How might you onboard a team member when the project is complicated and the existing team ar

What if we made design a part of the Agile Software Process? In This Episode: Emu Ranchers Agile Software Development Waterfall Model Design is how it works Download MP3

What’s the deal with FRP? Christoph gives us the skinny on Functional Reactive Programming. In This Episode: The Observer Pattern Deprecating the Observer Pattern Functional Reactive Programming Conal Elliott The Spreadsheet Metaphor bacon.js Publish Subscribe Pattern Download MP3

What if you wanted to write a fancy in-browser app but were less than enthusiastic about the Javascript ecosystem? In This Episode: Namespaces and the jQuery trick Punting on the whole issue and using (ahem) ClojureScript Javascript as the assembly of the web As Java begat JVM languages, so JavaScript begat JSVM languages? The appropriately named EcmaScript and its versions and implementations. Links: Clojure (I should just build this into the template.) Scala ClojureScript Scala.JS: » presentation, » infoq & » hackernews. CoffeeScript LispyScript: » hackernews. asm.js PhoneGap Building an iOS weather app with Angular and ClojureScript What is it with all this CamelCase. Aren’t we done with that yet? Download MP3

What if you ran your internal, closed-source, proprietary, mega-corporate projects like open source projects? Similar styles? Similar tools? In This Episode: First step in a software project? Meetings! But, but … what if we run internal projects like they were open source projects? Submitting patches to company projects, no matter where they are. IT departments: The people who say no. Internal utility projects? Or open source product products? Skunkworxing Pretending internally focussed apps are open source apps. The expensive barrier of entry for official projects. You can’t backlog an exploration. Feudalism and the company ownership of your skills. Toyota and the kanban thing. The Blue Ocean Notion Engineers, the trolls in the back room. The economy of getting things done. The meritocracy of things that work. We won’t discuss the merits of hard copy RSS. Open source repos as a way to avoid executive escalation. Branching another org’s project if they won’

This one’s all about the music. What if you had to rewrite your software after every release? In This Episode: The conceptual difficulties of other peoples' code, even when those other people are you. Legacy code and your own conceptual traps. Legacy code and demon possession. Legacy code and multiple personality disorder. What if you have to rewrite your code for each fix or deployment? “Write a new version of the code, minus the bug.” Lego oriented programming Binary vs texty interop ClassCastException vs sloppy parsers. “No, no. All shall match!” Log it and move on. Loosely coupled components vs statically-typed messages. The freedom to write crap code. The side-tracking concerns of the typical code review. “Okay, I’m having a connection.” Guitar! Writing code as performance. Improvisation, instruments, scores. Rewrite as process is kinda like jazz improvisation over a chart of chord changes, right? Sax might work better than a sympho

What if you can’t duplicate your production stack for testing and so on? For instance, factory software? I’m starting to think this whole podcast is, ultimately, about design. In This Episode: Steel mills Stackless programming (and we ain’t talkin' 'bout push/pop). What if you can’t run your software except in production? You can test but you can’t run. Your interfaces can never be too thin. Adapters outside the walled garden of perfection. The immutable log of perfection. What’s the difference between data streaming in from hardware, or replayed log data? The wall as observation post. You gotta go batch. The golden nugget and the matrix. Everybody gets a copy! How to engineer bugs for performance review goodness. “This whole things screams, ‘Messaging! Messaging!’” “This Facebook thing is confusing me a bit.” How many gamma bursts per angstrom? Human vs machine interface and the idea of a command protocol expressing

Thought experiments are all well and good, but sometimes you gotta try 'em out to see what’s what. In This Episode: Processing problematic log data using Clojure’s lazy sequences. Using Scala’s package objects to remove object oriented abstractions, and liking it! Download MP3

Can’t change your variables once you assign a value? WTF? Surely, this is something up with which we cannot put! Or: a round-about introduction to some of the concerns addressed by the functional programming paradigm. In This Episode: “I’ve been thinking about Object Oriented Programming.” “And you survived.” Concurrency and shared state Changing the value of 2 What if we can’t change a variable’s value? Side effects: minus the sides. And the effects. A functional primer and the unit test No side effects? No dependency injection! Does dependency injection break the “encapsulation” contract? Lock the doors so we can invent windows. Mock object makes a mockery of … well …. Separating values from behavior The inversion of the inversion Apparently, we’re really interested in address books. What about side-effects, though? I mean, right? Separating side-effects from calculations A walled-off garden of perfection Do

In this episode, we start with our conclusion and try to move on from there. In This Episode: What if we couldn’t use IDEs? Confessions What is an IDE anyway? Glade! The value is in the integration? IDE as antidote to problematic language choices. Metatool! The Bulldozer and the Treehouse Managing Java without an IDE How poor memory leads to simplicity Design patterns for the memory impaired PHP and the Abstraction Loving Programmer Football helmets and the damage they hide Implicitly magical Mutability causes debuggers or air planes or something IDEs can remember it for you IDE interface remains the same when the languages change Unix and Windows, reflections of their Eras in Tooling Wait for the tool maker, or be the tool maker? Weblogic Workbench: hooray! Rails: hooray! Did IDEs solve the problems of software complexity? Solve complexity by simplifying, not managing. Brazil! Managing CSS The Importance of Re-thinking Earnestly Creativity and Limitations What can I do

What if you were required to write a prototype for every significant development of your software system? In this episode: Prototypes as the only means of proposal New, bootstrappy architectures vs old, established architectures Prototype the non-code parts of the problem Prototypes as risk management for legacy, debt-encrusted systems Can you really prototype a monolithic mountain of madness? No prototyping without loose coupling? What is a prototype anyway? Distributed architectures and prototyping Prototype first as an antidote to the monolith A paper prototype is misleading Prototypes reveal the hidden horror beneath a beautiful diagram The value of a pre-prototype discussion Wherefore art thou estimation? Changing the meaning of change Prototypes: the enemy of status-quo or the safest way to grow? Download MP3

Our second podcast. This one got away from us in length, but it all adds up. Somehow. Does a project’s implementation strategy affect team dynamics? What if you couldn’t include tests in your source tree? Digressions abound! In this episode: Implications of architecture on team dynamics Programmer apathy The programmer hero The need to add value What if you couldn’t use unit tests? Confidence Metrics, instrumentation, data gathering and the real world Build systems just build App testing applications Testable apps Black box testing Domain experts and the unautomatable What can be confidently tested isn’t worth testing? Prepare for the un-preparable Breaking the build Baroque unit tests Unit tests as symptoms of a larger problem Bugs don’t matter until they matter The legacy of black box testability Download MP3

Welcome to the first episode of Flipping the Bozo Bit, a casual, conversational, podcast questioning the truisms of software development and management with plenty of digressions mixed in to taste. Download MP3