https://deliberate-software.com/ Recent content on deliberate software Hugo -- gohugo.io en-us Tue, 02 Aug 2022 00:00:00 +0000 https://deliberate-software.com/editor-abstraction-types/ Tue, 02 Aug 2022 00:00:00 +0000 https://deliberate-software.com/editor-abstraction-types/ Not all editing tools are created equal. Combining several simple ideas into one compound one, and thus all complex ideas are made - John Locke, An Essay Concerning Human Understanding (1690) While many words have been spent on the Holy Editor Flame Wars, I’ve read very little that attempts to categorize what they actually do. Likewise, everyone pays homage to the concept of using the “best tool for the job”, but few talk about when each tool would be best. https://deliberate-software.com/fsharp-design-enums/ Sun, 02 Dec 2018 00:00:00 +0000 https://deliberate-software.com/fsharp-design-enums/ F# provides a clear way to simplify invalid states with discriminated unions. Interdependent enums and booleans are a symptom of a design that could be simplified. Many domain records and classes contain enums and booleans that change in a “single transaction”. These are interdependent and often allow many states that are not valid for the business. Often they are designed this way because of the database. Consider a model I found last week that is stored in the database: https://deliberate-software.com/emacs-customization/ Tue, 05 Jun 2018 00:00:00 +0000 https://deliberate-software.com/emacs-customization/ I am working through the amazing Data 61 Functional Programming Course (seriously, put it on your list!) and I found myself doing a repeated set of actions. Repeated sets of actions are perfect for automation! The course has some sections with comments indicating the expected behavior: -- >>> parse (satisfyAll (isUpper :. (/= 'X') :. Nil)) "ABC" -- Result >BC< 'A' -- -- >>> isErrorResult (parse (satisfyAll (isUpper :. (/= 'X') :. https://deliberate-software.com/healthy-design-patterns/ Fri, 23 Feb 2018 00:00:00 +0000 https://deliberate-software.com/healthy-design-patterns/ Good design must be measurable Good software design should be scientific, universal, and measurable. Saying “this code is good”, or “this code is crap” is useless if we cannot even agree on what is good design. Design philosophies like “Single Responsibility Principle” can’t be objectively measured. The programmer must interpret if the code they are reading actually adheres to the pattern. Such an interpretation is subject to biases and confusion. https://deliberate-software.com/when-encapsulation/ Wed, 03 Jan 2018 00:00:00 +0000 https://deliberate-software.com/when-encapsulation/ Part 3 of the series OO-Design As discussed in the previous post Anemic Domain Models Are Healthy, encapsulation makes code harder to test. We should make important actions easy to do, and testing is important. Encapsulation and domain modeling are separate concepts. A good domain model is possible with or without encapsulation. Encapsulation is the design of trust boundaries between programmers. A well-encapsulated API ensures that other programmers cannot put your library or service into an invalid state. https://deliberate-software.com/optimization/ Tue, 05 Dec 2017 00:00:00 +0000 https://deliberate-software.com/optimization/ TL;DR: Made a website for optimizing Paragon cards using the GNU Linear Programming Kit and Haskell. Code available here. I love MOBA’s (Dota, LoL, Paragon), and I love Haskell. Since Paragon is my current go-to game, I wanted to determine the cards to buy to maximize my Damage Per Second (DPS). First things first, I found a spreadsheet of all the cards, colors, costs, and stats. Using some Vim magic, I made them into a list of tuples: https://deliberate-software.com/papers-we-love-1/ Fri, 04 Aug 2017 00:00:00 +0000 https://deliberate-software.com/papers-we-love-1/ In this series I practice reading computer science papers by following a modified set of steps outlined in the guide: How to read and understand a scientific paper: a guide for non-scientists. If your reaction to this post is ‘eh, just read the paper’, then this post isn’t for you ;) Why Should I Read The Byzantine Generals Problem? The research in this paper allows blockchain technology, ensures military radar installation reliability, and enables the design of distributed, fault-tolerant CPU processors. https://deliberate-software.com/poor-dsls/ Wed, 02 Aug 2017 00:00:00 +0000 https://deliberate-software.com/poor-dsls/ Trigger warning: this is a silly rant I wrote a few years ago after raging at the Hugo blog engine for a couple hours. I think its funny and still relevant, so hyperbolic nonsense incoming! DSL’s (Domain Specific Languages) are often terrible. Each DSL is a special snowflake, delicately floating from the heavens straight into in your eye. The problem with a DSL is that it always starts so simple. You take a complex problem and represent it simply with some nice pretty syntax. https://deliberate-software.com/patterns/ Tue, 01 Aug 2017 00:00:00 +0000 https://deliberate-software.com/patterns/ Design Patterns and Domain Driven Design are two of the most dangerous books a new developer can read. The books themselves are not bad. They offer standardized names for common programming practices, which has made communication a lot easier for everyone. Sometimes you will see that a pattern is merely a new name for something you may have already invented. Perhaps what you were calling a “builder” they call a “factory". https://deliberate-software.com/coq_day3/ Thu, 27 Apr 2017 00:00:00 +0000 https://deliberate-software.com/coq_day3/ Day three working through Software Foundations with Coq. Since I like to rant, and I love Darkest Dungeon, ENTER THE DARKEST PROOF. (Please don’t sue me!) I am trying to prove a helper proof to use to rewrite another helper proof to use to rewrite another proof for the commutativity of multiplication. You can’t make this stuff up. I just need to prove this where S n is n + 1: https://deliberate-software.com/self-organizing-balance/ Tue, 11 Apr 2017 00:00:00 +0000 https://deliberate-software.com/self-organizing-balance/ My team has a decade of experience applying self-organizing teams and pair-programming to reduce wasted productivity in an enterprise banking application. The Benefits No Technical Lead Our self-organizing practices eliminate the need for a technical lead who assigns and follows up on work. No work is assigned to any individual. Individual Empowerment Developers are free to remove pain points as needed, so most have a strong sense of ownership. Team members feel empowered to champion for broad changes to the codebase. https://deliberate-software.com/coq-day2/ Tue, 07 Feb 2017 00:00:00 +0000 https://deliberate-software.com/coq-day2/ Day two working through Software Foundations with Coq. Since I like to rant, and I love Darkest Dungeon, ENTER THE DARKEST PROOF. (Please don’t sue me!) Naming While trying to understand how rewrite works, I come across an obvious use-case: Theorem adding_n_Sm : forall n m : nat, n + S m = S n + m. Proof. intros n. induction n. simpl. reflexivity. simpl. rewrite <- IHn. At this point, in current scope I have: https://deliberate-software.com/coq-frustrations/ Wed, 01 Feb 2017 00:00:00 +0000 https://deliberate-software.com/coq-frustrations/ Day one working through Software Foundations with Coq. Since I like to rant, and I love Darkest Dungeon, ENTER THE DARKEST PROOF. (Please don’t sue me!) Precise Syntax I copied a sample from the book by hand, but it always caused Company-Coq to go into an infinite loop. I copied it again. Same deal. This isn’t my first rodeo, I’ve seen all sorts of syntax rules and such. But alas, it still fails. https://deliberate-software.com/anemic-domain-model/ Wed, 16 Nov 2016 00:00:00 +0000 https://deliberate-software.com/anemic-domain-model/ Part 2 of the series OO-Design The Anemic Domain Model is often quoted as an anti-pattern in the terminology of Domain-Driven Design. Martin Fowler goes so far as to term the alternative a “rich domain model”. A rich domain model makes perfect sense until you attempt to write your first unit test. You discover that rich domain models are very hard to test. Most examples of unit-testing use Anemic Domain Models! https://deliberate-software.com/better-oo-design/ Mon, 31 Oct 2016 00:00:00 +0000 https://deliberate-software.com/better-oo-design/ Part 1 of the series OO-Design The SOLID patterns are not enough to design a reusable and testable code base. Two concrete additions can significantly improve your codebase, while maintaining the SOLID principals. The suggestions here do not run counter to traditional SOLID designs, they enhance them. SOLID is a fine place to start, but it lacks a critical half of good design: polymorphic data. We’ve found polymorphic data is far more common than polymorphic behavior, so programs designed without that concept often are far larger than they need to be. https://deliberate-software.com/pairprogramming/ Mon, 12 Sep 2016 00:00:00 +0000 https://deliberate-software.com/pairprogramming/ My current team has pair-programmed and followed strict TDD on a single codebase for over ten years. The practices started from reading the literature on Extreme Programming, which resonated with both the developers and leadership. As the team changed, we continued to follow the practices. In the last five years, the developers choose to implement Arlo Belshee’s “Promiscuous Pairing”. We switch pairs in short intervals: 180 minutes is our current preference. https://deliberate-software.com/vim-refactoring-patterns/ Wed, 22 Jun 2016 00:00:00 +0000 https://deliberate-software.com/vim-refactoring-patterns/ Editor macros are a secret weapon for editing text. While they are hard to learn, no other tool offers such broad speed and power for automating changes. A skilled macro wielder can make huge changes to a codebase with ease. Here are some inspirational patterns to demonstrate major structural refactorings using Vim macros and search/replace commands. Reorder A List Of Numbers A change left me with a file with unordered numbers. https://deliberate-software.com/modern-di/ Sat, 11 Jun 2016 00:00:00 +0000 https://deliberate-software.com/modern-di/ Dependency Injection can be greatly simplified while retaining all of its power. The Unnecessary Boilerplate Injection of an interface through the constructor is a common way to replace a dependency for unit-test mocking. Unfortunately, it is an extremely verbose pattern. Look how much boilerplate is needed just to mock out a call to DateTime.Now: 1public interface ICurrentTime { 2 DateTime GetCurrentTime(); 3} 4 5public class CurrentTime : ICurrentTime { 6 public DateTime GetCurrentTime() { 7 return DateTime. https://deliberate-software.com/editor-abstractions/ Mon, 23 May 2016 00:00:00 +0000 https://deliberate-software.com/editor-abstractions/ (Want to become a Vim expert? Check out my new book: 10 Minute Vim) I was recently inspired by a comment from a respected coworker: “I am just as productive with basic Vim commands as I am with a refactoring suite like ReSharper.” I have pair-programmed with him for hundreds of hours of C# development. He is equally productive with both, that much I know. On some tasks he is less efficient than with ReSharper, on others he is more. https://deliberate-software.com/haskell-state/ Wed, 27 Apr 2016 00:00:00 +0000 https://deliberate-software.com/haskell-state/ Part 2 of my series “Wrangling State”. Part 1 Wrangling State In Clojure Haskell is a pure language, so you can only deal with application state by passing parameters to functions. It is possible to pass parameters more conveniently, but ultimately, every parameter needs to be passed. Here is a simple application for logging a timestamp to a file. First, Pass As Parameter: loadFile :: Filename -> IO String loadFile fileName = BS. https://deliberate-software.com/figwheel-angular2/ Wed, 13 Apr 2016 00:00:00 +0000 https://deliberate-software.com/figwheel-angular2/ In “Using Angular2 in Clojurescript” I showed how to get ClojureScript to run an Angular2 template. Basic hotswapping worked, but state was lost on each load. Tweaking the original demo allows for figwheel to swap in the template without losing client state. Here is a demo of hotswapping with state preservation: In this demo, we add three things to a list, then change the template that draws the list. The client state stays in the browser, while the template changes around it! https://deliberate-software.com/cljs-angular2/ Mon, 11 Apr 2016 00:00:00 +0000 https://deliberate-software.com/cljs-angular2/ Getting ClojureScript to run Angular2 is not very difficult. Here is a sample project demonstrating a working Angular2 site using Figwheel for hot-reloading on GitHub 1. Install Luminus +cljs First, setup a basic ClojureScript site using Luminus starter template from here lein new luminus cljs-angular2 +cljs This builds a great basic starter project with ClojureScript and figwheel already running. The template uses Reagent and React, which are excellent, but we want Angular2! https://deliberate-software.com/clojure-state/ Tue, 29 Mar 2016 00:00:00 +0000 https://deliberate-software.com/clojure-state/ “Clojure is immutable, so you can’t change anything, how useless!” Immutable languages make application state an interesting concept. In Clojure, you can deal with application state in two main ways. The first way is to pass the state around as parameters to your functions. An example of Pass As Parameter: (defn delete! [db-con table id] (jdbc/delete! db-con table ["id=?" id])) ;; valid-for-delete omitted (defn delete-user [db-con user-id] (if (valid-for-delete db-con "user" user-id) (delete! https://deliberate-software.com/self-organizing-teams/ Wed, 16 Mar 2016 00:00:00 +0000 https://deliberate-software.com/self-organizing-teams/ A self-organizing team can be one of the most effective ways to build a team of high-quality professionals. What Is A Self-Organizing Team? I have managed several self-organizing teams over the last few years. They are expected to follow these tenets: The whole team organizes themselves to best meet the business needs Each team chooses their practices and working agreements All technical and organizational decisions are driven through consensus Product owners determine “what” happens, the team determines “how” All staff participates in a culture of high-quality development Systems and practices are designed to maintain the greatest productivity across the next decade When It Works Well Small teams Highly skilled workers Need for high-quality software Business need for continuous and stable productivity for 5+ years Buy-in from management that “productivity is worth feeling out of control” Self-organizing teams work best when most people on your team are eager to do more, be more, and learn more. https://deliberate-software.com/pop-culture-architecture/ Fri, 19 Feb 2016 00:00:00 +0000 https://deliberate-software.com/pop-culture-architecture/ “ActiveRecord is so hot right now!” - comment in 2006 Pop Culture Architecture is the current “fad” of the day. I have seen it be microservices, business capabilities, CQRS, service-oriented architecture, Domain-Driven Design, test driven development, ORMs, ActiveRecord, and MVC. Each of these have been fashionable at some point. Fashion is ultimately a signaling mechanism for status. We are attracted to fashionable architectures because they signal we have worked on elite teams. https://deliberate-software.com/haskell-is-the-dark-souls-of-programming/ Sat, 06 Feb 2016 00:00:00 +0000 https://deliberate-software.com/haskell-is-the-dark-souls-of-programming/ Please don’t hit me, Haskell does a great job of that already. I love Haskell for the same reasons I love Dark Souls. Fantastic and inscrutable lore, a great combat type system, a cliff-wall difficulty curve, and unending punishment. I want to collect some statistics from the GitHub API. Step One - Stack I download stack and start a project: > cd /home/jack/programming && stack new github-stats && cd github-stats Downloading template "new-template" to create project "github-stats" in github-stats/ . https://deliberate-software.com/development-disappointment-disorder/ Thu, 04 Feb 2016 00:00:00 +0000 https://deliberate-software.com/development-disappointment-disorder/ “We’ve never had a successful release” You just finished this really hard feature. The whole thing was worse than anyone realized. Not only that, but the feature wasn’t clearly explained, so you lost time churning on the actual requirements. Despite all the confusion, iteration, and technical challenges, you managed to get it working! You look back, savoring how much you have learned and grown. You show it off to the product owner. https://deliberate-software.com/compassionate-interviewing/ Mon, 11 Jan 2016 00:00:00 +0000 https://deliberate-software.com/compassionate-interviewing/ After my post Interview Humiliation, a number of people have asked me how I interview compassionately. I strive to make my interviews as stress-free and respectful as possible while still rendering a yes/no at the end. Any good interview process needs to start with goals: Respect the candidate’s time Make the candidate comfortable Under-skilled candidates should feel no shame Both passing and failing candidates should want to tell their friends to apply We should render the same decision if the interview is repeated multiple times (with different exercises each time) The candidate should know the process in advance and not be able to earn a pass through short term “cramming” The candidate should feel we are all working collaboratively, instead of us against them The Ideal Candidate https://deliberate-software.com/daily-meditation-greatly-improved-my-technical-leadership/ Mon, 14 Dec 2015 00:00:00 +0000 https://deliberate-software.com/daily-meditation-greatly-improved-my-technical-leadership/ A couple years ago, a coworker told me a success story about mindful meditation. He explained how his wife took a class that required an hour of daily meditation for a whole month. He reported that she found it uncomfortable, but the effects were astounding. She claimed to feel more relaxed, more focused, and more “herself”. She found new reserves of motivation. She dropped the book she’d been trying to write for years, and started a business. https://deliberate-software.com/teaching-clojure/ Wed, 18 Nov 2015 00:00:00 +0000 https://deliberate-software.com/teaching-clojure/ My talk at Conj 2015, enjoy! Teaching Clojure https://deliberate-software.com/on-defeat/ Thu, 29 Oct 2015 00:00:00 +0000 https://deliberate-software.com/on-defeat/ (All these great ideas, but no one is listening? Check out my book: Convincing Coworkers) One day, I went into an interview, and I was humiliated. The Setup I used to think very highly of myself. This was early on in the Test Driven Development (TDD) craze, and I was one of the best I knew at it. I knew interfaces, classes, mocking frameworks, and best practices. I’d been taught all the tricks from some very smart people, and my confidence was high. https://deliberate-software.com/f-number-unit-testing/ Wed, 21 Oct 2015 00:00:00 +0000 https://deliberate-software.com/f-number-unit-testing/ If you are considering using F#, you might be curious how to handle unit test mocking, especially if you want to use both modules and classes. In a language like C# or Java, the common method is to a DI container or handmade constructor injection on a class. These “entry points” allow for a unit test to replace a real dependency with a test-only replacement. I previously posted an example that shows a much simpler way to inject dependencies called the SimpleMock pattern. https://deliberate-software.com/simplemock-unit-test-mocking/ Thu, 13 Aug 2015 00:00:00 +0000 https://deliberate-software.com/simplemock-unit-test-mocking/ SimpleMock is a pattern for reducing TDD damage. You can use the pattern to organize your testing code without mocking or complicated dependency injection. SimpleMock works in any language with closures that can be passed around by reference, so off the top of my head: C#, Java, F#, Scala, PHP, C++, Ruby, and Python. I’m sure you can think of others. Example: Here is a brief (if a bit silly) example of the final pattern: https://deliberate-software.com/safety-rank-part-2/ Fri, 24 Jul 2015 00:00:00 +0000 https://deliberate-software.com/safety-rank-part-2/ I want to make a model that predicts bugs. I previously wrote a table for scoring language safety: Programming Language Safety Score, but it was extremely time consuming to score new languages or make modifications. Simplify, Simplify After being told I was overfitting the data, I’ve attempted to clean up by simply checking if each category is enforced, possible, or impossible. I score each as either 1 (language enforced), 0 (possible, but you have to remember to do it), or -1 (impossible). https://deliberate-software.com/language-versions/ Mon, 20 Jul 2015 00:00:00 +0000 https://deliberate-software.com/language-versions/ Let’s play a thought exercise. Imagine your development toolchain is like a semantic version number. Small features that incrementally improve your situation are like minor updates. They don’t cause any large shifts in thinking or process. Major updates are big, new concepts, quantum jumps in theory or practice. I am not talking about the political, social, or financial aspects of a toolchain. For example, hiring is a complex beast entirely in its own category. https://deliberate-software.com/learning-lisp-was-hard/ Wed, 17 Jun 2015 00:00:00 +0000 https://deliberate-software.com/learning-lisp-was-hard/ Several times in the last week people have lamented to me that they “just don’t get Lisp”. After hearing it for the third time, I thought back to my experience learning a Lisp. When I set out to learn a Lisp, I expected it would be easy. I figured, “I am pretty awesome at PHP, and have worked professionally in Perl, Python, and Java, this should be a cakewalk!” I’d read Paul Graham’s essays on how Lisp is his secret weapon, and figured I needed to get into this secret weapon stuff. https://deliberate-software.com/superiority-fatigue/ Thu, 14 May 2015 00:00:00 +0000 https://deliberate-software.com/superiority-fatigue/ Learning new tools, technologies, and methodologies is hard. Counter-intuitively, the most exhausting part is after you’ve gained a good comprehension of the tool, and now, filled with excitement, you try to explain it to someone else. They almost always react with hostility. What is going on? You just took time to learn this exciting tool that could save everyone a lot of time, and not only do they not care, but they resent you for it! https://deliberate-software.com/pattern-matching-case-study/ Sat, 14 Mar 2015 00:00:00 +0000 https://deliberate-software.com/pattern-matching-case-study/ Domain modeling in F# is significantly easier and safer than with the traditional .NET languages. This is because of the increased safety of pattern matching and the expressiveness of discriminated unions. These concepts are not in C# or VB.NET, and therefore bring a new tool to the table. To illustrate this, I found some old code I’d written to interact with a legacy system. The system uses many single enums on a record to keep track of statuses. https://deliberate-software.com/programming-language-safety-algorithm/ Tue, 17 Feb 2015 00:00:00 +0000 https://deliberate-software.com/programming-language-safety-algorithm/ I think the time has come for a standard programming language safety score. I want to use this model to help show that the concept of safety is much more nuanced than a binary bit of “has strong-static types”. When someone says “programming language safety”, it typically invokes thoughts of unit tests, long build times, and red squiggles in an IDE. But, in day-to-day development, there are so many times when we are bitten by things that somehow just slip through the cracks. https://deliberate-software.com/unusual-reasons-why-clojure-is-a-delight/ Mon, 09 Feb 2015 00:00:00 +0000 https://deliberate-software.com/unusual-reasons-why-clojure-is-a-delight/ Clojure is a delightful language, and here are six uncommonly discussed reasons why. 1 - Dead Simple Unit Test Mocking Clojure is the easiest language to unit test I have ever seen. “Mocking” a function in a test only requires a simple replacement of the function definition. No extraneous interfaces, no dependency injection, no mocking framework. The built-in function with-redefs will replace any function in any library or namespace with a new definition. https://deliberate-software.com/christmas-f-number-polymorphism/ Sat, 06 Dec 2014 00:00:00 +0000 https://deliberate-software.com/christmas-f-number-polymorphism/ One of my favorite things about F# is how it lets you choose how you want to align your data. In the previous posts highlighting on pattern matching and inverted polymorphism we covered how pattern matching in F# is safer than if statements and can replace classes and interfaces for polymorphism. If you are unfamiliar with these concepts, you might want to skim those first. Today, for the 6th day of the F# Advent Calendar I wanted to highlight F#‘s flexibility in solving the “expression problem". https://deliberate-software.com/emacs-project-tip/ Sat, 06 Dec 2014 00:00:00 +0000 https://deliberate-software.com/emacs-project-tip/ I recently have been working in a Clojure project which is made up of several microservices. While trying to build in a secure method for each service to be able to call the others, I’ve been in several different projects at the same time. At least once I accidentally opened the wrong “handler.clj” buffer, and spent a few minutes adding a function that never worked. Since I hate doing things like this, I wanted a simple way to see what project I was currently viewing. https://deliberate-software.com/skill-continuum/ Tue, 02 Dec 2014 00:00:00 +0000 https://deliberate-software.com/skill-continuum/ (Want to become a Vim expert? Check out my new book: 10 Minute Vim) > Learning Vim is a waste of time; I can prove it! - Anonymous I recently had a gentle discussion with a new teammate about whether or not they should learn to use Vim. My team uses a Vim emulator inside Visual Studio and Emacs, and so we recommended he learn at least the basics so to reduce friction when pair-programming (which we do almost all the time). https://deliberate-software.com/next-book/ Sat, 26 Jul 2014 00:00:00 +0000 https://deliberate-software.com/next-book/ Edit: As a supplement to this: check out my favorite books. “It’s my first job, what book should I read first?” I’ve been asked this question many times. Even mid and senior level developers I’ve known sometimes struggle with this question. If you want to be truly great, you have to read technical books and white papers, and you have to learn new programming languages. You could figure the content out yourself from first principles, but you will be about 50 years behind those who just read the books. https://deliberate-software.com/inversed-polymorphism/ Mon, 28 Apr 2014 00:00:00 +0000 https://deliberate-software.com/inversed-polymorphism/ In my last post on the power of pattern matching, we saw how powerful the match statement is in F#. Using match allows the compiler to give us warnings for missing cases, no matter what the type. Let’s look at how pattern matching changes our design, allowing for an inversion of the usual OO way of polymorphism. Here is an example that is probably familiar to everyone: getting a database connection. https://deliberate-software.com/function-pattern-matching/ Mon, 28 Apr 2014 00:00:00 +0000 https://deliberate-software.com/function-pattern-matching/ Pattern matching is a simple tool that will make your code safer and easier to read. Consider the following code that converts an Int to a string. public enum Language { Spanish, English } public static string convert(int number, Language lang) { string ret = ""; if (lang == Language.English) { switch(number) { case 0: ret = "zero"; break; case 1: ret = "one"; break; default: ret = "..."; break; } } else if (lang == Language. https://deliberate-software.com/learn-to-database/ Wed, 16 Apr 2014 00:00:00 +0000 https://deliberate-software.com/learn-to-database/ "... and it has to return 45,000 records a minute, or we are all screwed." Monday morning, we inherited a legacy codebase. Tuesday, the word came down on stone tablets. Forty-five thousand records a minute, and no amount of political maneuvering or incremental gains were going to do. Too many broken promises. The last team mass quit over three months, leaving us the two most junior developers. Someone high up promised big, and the buck stopped with us. https://deliberate-software.com/501-developer/ Sat, 14 Dec 2013 00:00:00 +0000 https://deliberate-software.com/501-developer/ Can we agree for this post that money, energy, time, and effort are all forms of power? Like literally, if I wanted to build a building, I am going to need tools, skills, materials, labor. I can use the most liquid form of power I have (cash) to acquire all these things, or I can use a much less liquid form of power (my time) to harvest, extract, refine, learn, and build my building myself. https://deliberate-software.com/intro-to-macros/ Mon, 19 Aug 2013 00:00:00 +0000 https://deliberate-software.com/intro-to-macros/ Macros are the most powerful way to manipulate the syntax of your language. Macros make it possible to completely modify your language to match your domain. To explain them, think for a minute about functions using the simple “substitution model” used to teach functions to beginner programmers. The substitution model has the reader replace a function call with the body of the called function. def doCalc () return 1 + 2 end def doAwesome (x) return doCalc() + x end #before substitution. https://deliberate-software.com/clojure-debugger/ Wed, 07 Aug 2013 00:00:00 +0000 https://deliberate-software.com/clojure-debugger/ I was at the Clojadelphia meetup on Thursday, and got an excellent run through of the tools.trace library from Tim Visher. He has submitted a pull request to the original authors, with his expanded and very clear documentation found here. One call from the library in particular really stood out, a call for finding out what form threw an exception out of many. ;; trace-forms "Trace all the forms in the given body. https://deliberate-software.com/refactoring-not-free/ Mon, 27 May 2013 00:00:00 +0000 https://deliberate-software.com/refactoring-not-free/ Sometimes, it’s far more efficient to leave certain technical debts unpaid. I’m not saying we should leave messes, instead I am saying that cleaning and fixing technical debt is so important we must prioritize the most important changes first, by highest value to the team. You don't just do whatever feature is next alphabetically do you? Nope, so neither should you do that with refactorings. Not all technical debts are created equal: they consist of varying amounts of interest as well as principal. https://deliberate-software.com/how-to-escape-from-programming_language/ Wed, 13 Mar 2013 00:00:00 +0000 https://deliberate-software.com/how-to-escape-from-programming_language/ As time goes on, developers will be all the harder pressed to keep up with the skyrocketing number of languages and frameworks. The number of javascript libraries alone is increasing at a furious pace: Angular, Backbone, Node, Ember, Knockout, Knockback, Meteor, etc, etc, etc. Who has a chance at keeping up? While having so many options is also beneficial, it makes it more and more challenging for a single developer to stay relevant. https://deliberate-software.com/new-job-todo-list/ Sat, 19 Jan 2013 00:00:00 +0000 https://deliberate-software.com/new-job-todo-list/ One thing I strongly recommend to developers when starting at a new job is to keep a list of everything that bothers you. For every new company you work at, there will always be a set of things that you see as pain points, because you came from a place that did those things differently. Notice I said differently, not better. All of us have certain irrational attachments to the various things we are used to doing: things we do not because it’s the best way to do them, but because it’s become comfortable to do them that way. https://deliberate-software.com/ego-driven-development/ Fri, 12 Oct 2012 00:00:00 +0000 https://deliberate-software.com/ego-driven-development/ Ego Driven Development, (EDD), is a software development anti-pattern where developers and managers repeatedly act as if established best practices do not apply to them, to the detriment of their organization. Institutional ego is most often to blame. EDD plagues many organizations; here just some of the symptoms you might encounter: “Not Invented Here” syndrome. Expressed most commonly in a desire for everything needed to be developed in house. https://deliberate-software.com/end-to-end-web-service-testing/ Fri, 12 Oct 2012 00:00:00 +0000 https://deliberate-software.com/end-to-end-web-service-testing/ At work last month, I was assigned to fix some bugs in an asynchronous legacy code base. My supervisor gave me a month to see what I could do, and to see if I could fix a few tricky bugs. The code is divided into two sections, a client application and a web server. Both the client application and the server have their own persistence, and they communicate through a soap web service. https://deliberate-software.com/learn-that-new-programming-language-the-start/ Tue, 07 Aug 2012 00:00:00 +0000 https://deliberate-software.com/learn-that-new-programming-language-the-start/ I have a method I use for rapidly learning new programming languages that I wanted to share because I have not really seen it documented anywhere else. This technique is not for the faint of heart, but it is a lot of fun. Many of you old hands and graybeards probably already do this, but for those that don't, you have got to give it a shot at least once. You'll never be the same. https://deliberate-software.com/on-developer-certifications/ Tue, 28 Feb 2012 00:00:00 +0000 https://deliberate-software.com/on-developer-certifications/ I have often thought whenever I meet a programmer who is obviously grossly incompetent that there needs to be some sort of certification board for software engineering that can help enforce some minimal skills to help weed out the riff-raff.Obviously, this is completely impossible. The tools and community change so fast that individuals are barely able to stay on top; good luck getting a standards committee to completely revise every few months. https://deliberate-software.com/quality-is-future-speed/ Thu, 23 Feb 2012 00:00:00 +0000 https://deliberate-software.com/quality-is-future-speed/ Lately, I have been deliberating on quality vs. speed. Throughout my career, I have worked with developers who basically consider quality to be a programmer's vice, an extravagance only for the navel-gazing idealists. I have also worked with developers who consider all time spent on quality to be of the utmost importance, and that programming for speed is for those lazy and slapdash realists. I recently read Yegge's post Done, and Get's Things Smart, and I think I agree with Yegge on this point, that it is possible to perform fast and with high quality, and like a wandering samurai, that is the path I seek. https://deliberate-software.com/new-years-triumph/ Sun, 01 Jan 2012 00:00:00 +0000 https://deliberate-software.com/new-years-triumph/ December 1st, I made myself a New Year's resolution to completely create an Android game that I would not be ashamed to show people from (mostly) scratch before the end of December. What made it the most fun was that I started with practically no experience with the Android platform at all, and so I got to pick it up by the seat of my pants.The biggest challenge was probably the last three days, where I was faced with some hard calls, when the deadline loomed, and my still mile-long list of wants had to be pruned down just about every few hours. https://deliberate-software.com/why-i-cant-get-focused-its-a-double-entendre/ Wed, 14 Dec 2011 00:00:00 +0000 https://deliberate-software.com/why-i-cant-get-focused-its-a-double-entendre/ I can't get focused today. My mind is a torrent of activity completely unrelated to my task at hand, so I am writing this to get these thoughts out so I can get back to work.I got a call from a recruiter the other day trying to get me to come interview at this job. Right now I am working in VB.NET and Actionscript. Until this job, I was always working in open-source languages: Perl, PHP, and some Java. https://deliberate-software.com/testing-is-to-programming-what-math-is-to-eng/ Mon, 26 Sep 2011 00:00:00 +0000 https://deliberate-software.com/testing-is-to-programming-what-math-is-to-eng/ In ancient times, plenty of builders did their work without math, and I would guess that a good portion of them likely did it faster then their math-doing counterparts. I am certain that when builders first started using math to prove that buildings would stand up safely, they were mocked by their math-less counterparts. I can hear them now, "Oh, Stephos, it takes you 5 times longer to prove your building will stand up, real men can just see that it will work" https://deliberate-software.com/the-endless-debate/ Fri, 22 Jul 2011 00:00:00 +0000 https://deliberate-software.com/the-endless-debate/ The last three and a half years for me have been terrible. Why? Well, three and half years ago, I discovered the endless debate, Emacs vs. Vim. Being an efficiency nut, I could not fathom the horror of learning one, and by that action, not learning the other. What if the one I learned was not the "best" one? I could see that both were excellent and worth learning, but I wanted to learn both concurrently. https://deliberate-software.com/lisp-repl/ Sat, 04 Jun 2011 00:00:00 +0000 https://deliberate-software.com/lisp-repl/ So, working through the Land of Lisp book, getting the hang of it. Chapter Six, the author starts off by talking a little about the Common Lisp REPL, or Read-Eval-Print-Loop that you use as sort of the "command line" for interacting with lisp. It is pretty cool, you type in code, and it executes. And then he opens the hood a little: (defun repl () (loop (print (eval (read))))) WHAAAAAAAAAAAAAAA? https://deliberate-software.com/dont-mock-concrete-classes/ Tue, 24 May 2011 00:00:00 +0000 https://deliberate-software.com/dont-mock-concrete-classes/ (They have thin skin) I have been reading G.O.O.S. and honestly, much of it has been just a reiteration. Until chapter 20, that is. I get to the section Don't Mock Concrete Classes, and it clicks. Mocking concrete classes used to be my bread and butter. Almost every unit test I wrote for the last year had several mocked concrete implementations, to pass in as dependencies of the system under test. https://deliberate-software.com/on-lisp-part-1/ Fri, 20 May 2011 00:00:00 +0000 https://deliberate-software.com/on-lisp-part-1/ I have been playing around with lisp off and on for some time now. I started out in Emacs Lisp, making Emacs play as nice (nicer in some ways) as any available php ide, but then dropped off after discovering PhpStorm from JetBrains. When I heard about Land of Lisp, I was intrigued and picked up a copy to work through over Christmas, got a few chapters in, but as Christmas tends to go for me, I spent much of the time playing board games with the family. https://deliberate-software.com/using-named-parameters/ Thu, 05 May 2011 00:00:00 +0000 https://deliberate-software.com/using-named-parameters/ Up until recently, most of my programming was in php, which does not support named parameters (this doesn't count, and it will get you lynched) so while switching to VB.NET and python, I have come to really appreciate this handy feature. Named parameters is one of those handy little things that can make your life a little easier. Say, in python, you have a function that takes a boolean value. https://deliberate-software.com/actionscript-unit-testing/ Wed, 04 May 2011 00:00:00 +0000 https://deliberate-software.com/actionscript-unit-testing/ I am trying to test a project that is huge and many of the "classes" are only defined as linkages from the main monster fla. I followed ASUnit Tutorial and got it to work with their simple examples. But when I went to test a factory and child class I had just written (hey, I would have tdd�d, but then I would not have know if it was failing for the right reason), it would not compile, hanging up on some of those undefined "exported linkage" classes. https://deliberate-software.com/active-record-pattern-testing/ Tue, 12 Apr 2011 00:00:00 +0000 https://deliberate-software.com/active-record-pattern-testing/ One of the most interesting problems I have had to face recently was in testing Active Record objects representing entities in a database. In this instance, the classes were legacy, and many were hundreds of methods long. Testing these classes was a nightmare, as any modifications to class properties resulted in an automatic database update at the end of the session (and test). Additionally, the top ten largest classes all had dozens of references between each other, and their creation and retrieval was all built into the class as static methods. https://deliberate-software.com/papers_we_love_page2/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/papers_we_love_page2/ https://lamport.azurewebsites.net/pubs/lamport-paxos.pdf http://cidrdb.org/cidr2005/papers/P12.pdf https://amturing.acm.org/p558-lamport.pdf https://bitcoin.org/bitcoin.pdf https://deliberate-software.com/page/training/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/page/training/ A path to full-time software development "I Just Finished CodeAcademy/Khan Academy/etc, Now What?!" Breaking into a new career can be intimidating! Many people get stuck after finishing an online course like CodeAcademy. We want to provide free guidance necessary to get that dream job. Success Stories We have used this program with several people to help them break into full-time software developer jobs: Rachel B. Rachel was working as a baker when we started together. https://deliberate-software.com/page/philosophy/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/page/philosophy/ Hi, I am Steve Shogren! I am a developer and manager who has met needs in the financial, education, and publishing industries. I grow self-organizing teams and empower them to achieve tremendous business value. My Philosophy Strategic Self-Organizing Teams When carefully mentored, a self-organizing team accomplishes the most business value. Servant Leadership Empowering and trusting your team increases intrinsic motivation, engagement, and productivity. https://deliberate-software.com/page/focused/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/page/focused/ Targeted Posts top Books That Shape My Thinking Learn To Program For Free What Keeps a Self-Organizing Team From Falling Apart Ten Years of Pair Programming Daily Meditation Improves Technical Leadership Ego Driven Development new developers Learning Lisp Was Hard Suggested Skill Progression What Book Should I Read Next? You Should Go Home at 5:01 How to Suck Less at Your New Job seasoned developers Avoid Pop Culture Architecture Haskell is the Dark Souls of Programming SimpleMock: Language Agnostic Unit Test Mocking Programming Language Safety Score Mark 2 Pattern Matching - Making the Compiler Work For You managers When Self-Organizing Teams Are Effective Designing A Compassionate Interview For A High Performing Individual Daily Meditation Improves Technical Leadership Better Interviews Ego Driven Development https://deliberate-software.com/page/post/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/page/post/ All Posts Posts Powerful Editor Abstractions technical skills vim F# Domain Design: Interdependent Enums and Booleans Technical Skills fsharp csharp Simple Haskell Automation in Emacs technical skills emacs fp-course Scientific Software Design: Human Working Memory technical skills oo-design OO-Design Part 3: When to Apply Encapsulation technical skills csharp java oo-design MOBA Item Optimization In Haskell technical skills Papers We Love: The Byzantine Generals Problem technical skills academic papers proofs DSLs Are Terrible hugo dsl Technical Skills silly Design Pattern Dangers technical skills Darkest Proof: Day 3 technical skills coq proofs silly What Keeps a Self-Organizing Team From Falling Apart management meta game self-organization Darkest Proof: Day 2 technical skills coq proofs silly Darkest Proof: Day 1 technical skills coq proofs silly OO-Design Part 2: Anemic Domain Models Are Healthy technical skills csharp java oo-design OO-Design Part 1: Increasing Reuse With Noun Interfaces technical skills csharp java oo-design Ten Years of Pair Programming management unit-testing self-organization Vim Refactoring Patterns technical skills vim refactoring Modern Dependency Injection technical skills architecture csharp unit-testing Editor Abstractions technical skills emacs vim Wrangling State In Haskell technical skills haskell Hot Loading Angular2 With State technical skills clojure clojurescript angular Using Angular2 in ClojureScript technical skills clojure clojurescript angular Wrangling State In Clojure technical skills clojure When Self-Organizing Teams Are Effective management meta game self-organization Avoid Pop Culture Architecture architecture Technical Skills Meta game Haskell is the Dark Souls of Programming haskell Technical Skills silly Development Disappointment Disorder Meta Game management Designing A Compassionate Interview For A High Performing Individual Meta Game management Daily Meditation Improves Technical Leadership Meta Game management Conj Talk: Teaching Clojure at IBM Meta Game clojure Better Interviews meta game interviews management F# Unit Testing With SimpleMock fsharp unit testing Technical Skills SimpleMock: Language Agnostic Unit Test Mocking unit testing csharp Technical Skills architecture Programming Language Safety Score Mark 2 haskell clojure fsharp csharp Technical Skills Language Versions Learning Lisp Was Hard clojure Meta Game Superiority Fatigue Meta Game Case Study: Superior Domain Modeling in F# Technical Skills fsharp csharp Programming Language Safety Ranking Technical Skills clojure fsharp csharp Six Unusual Reasons why Clojure is a Delight clojure Technical Skills Unit Testing Christmas F# Polymorphism Technical Skills fsharp architecture Emacs Project Tip Technical Skills emacs Suggested Skill Progression Technical Skills Meta Game management What Book Should I Read Next? https://deliberate-software.com/page/books/ Mon, 01 Jan 0001 00:00:00 +0000 https://deliberate-software.com/page/books/ Writings That Shape My Thinking For how I pick what books to prioritize, check out my post "What Book Should I Read Next?“. Bold are my highest recommendations. The indicates a link with a summary. System Design Designing Data-Intensive Applications Patterns of Enterprise Application Architecture The Tangled Web Design Of Everyday Things Growing Object-Oriented Software Guided by Tests Propagation Networks: A Flexible and Expressive Substrate for Computation People Management Reinventing Organizations Peopleware Good To Great Becoming A Technical Leader Emotional Intelligence 2.